Chapter 2 Essential Building Blocks of Computer Programs

Rules of Naming Identifiers

In addition to uniqueness, identifiers used in Python programs must be named according to the following rules:

1. 1. An identifier can be a combination of letters (a–z, or A–Z), numbers (0–9), and underscores (_).
2. 2. It must begin with a letter (a–z or A–Z) or underscore (_).
3. 3. In Python, identifiers are case-sensitive, so x and X are different identifiers.
4. 4. Identifiers can be of any length.
5. 5. User-defined identifiers cannot be the same as words reserved by the Python language.

According to these rules, the following are legitimate user-defined identifiers in Python:

AB, zf, cd, hz, d_2, c5E, falling, to_be

Whereas the following are not:

1d, d/, f-, g.d

In Python, identifiers shown in Table 2-1 are reserved and hence called reserved words or keywords, with predefined special meaning in the language, which means that you must not use them to name your variables, functions/methods, classes, or modules.

In addition to the reserved words in Table 2-1, you should also avoid using names that have been used by Python for built-in types and built-in functions, classes, and modules. These names are collectively called built-in names. It is grammatically fine to use built-in names as user-defined identifiers, but using them may cause confusion.

Furthermore, Python also uses the underscore _ as an identifier for a very special variable to hold the result of the last evaluation when Python is running in interactive mode, as shown in the following example:

This use of _ as a special variable can also be seen in Jupyter Notebook, as shown in the following example:

When Python is not running in interactive mode, _ has no predefined meaning, however. Even within Jupyter Notebook, the value of _ is often unpredictable unless explicitly assigned.

Syntactically, the special variable _ can be used in the same way as others, especially when the value is to be thrown away and not used, as shown below:

Python Naming Conventions

Although identifiers used in Python programs don’t have to be meaningful to humans, you should always try to use more meaningful identifiers in your programs because it is not only easy for you to tell what the identifiers are used for but also easier for other programmers to understand your programs when you work in a team or want to share your code with others.

For the same reason, you should also follow common practices and widely accepted coding conventions when programming. In terms of composing identifiers these conventions include:

1. 1. Lower case identifiers are usually used for variables and function names.
2. 2. Capitalized identifiers are used for class names.
3. 3. Upper case identifiers are used for constants, such as PI = 3.1415926, E = 2.7182, and so on.
4. 4. When an identifier has multiple words, the underscore _ is used to separate the words. So we use your_name instead of yourname, use to_be instead of tobe. Some programmers prefer not to use an underscore, but to capitalize each word, except for the first word, when an identifier is used as a variable or the name of a function or method.

Along with the programming technologies, these practices and conventions have developed over the years and may further evolve in the future. A good Python programmer should follow the developments and trends of the Python programming community.

Names with Leading and/or Trailing Underscores

As mentioned above, identifiers for variables, function/method names, and class names may begin and/or end with a single underscore, double underscores, or even triple underscores, and those names may have special meanings.

When a name has both leading and trailing double underscores, such as __init__, it is called a dunder (double-underscore) name. Some dunder names have been given special meanings in Python Virtual Machine (PVM) or a Python interpreter. They are either reserved as special variables holding special data or as special function/method names.

The following are some special dunder names used as special values or special variables holding special data.

__main__

Used as a special value. When a Python program/script file runs as the main program other than a module, the special variable __name__ will be assigned special value __main__.

__name__

Used as a special variable in a Python program to hold special value indicating how the program file is called or used. If the program file is used as the main program, __name__ will hold __main__. If it is used as a module, __name__ will hold the name of the module.

__package__

Used as a special variable to hold the package’s name if a module imported is a package. Otherwise, __package__ will hold an empty string.

__spec__

Used as a special variable to hold the module specification used when the module is imported. If the Python program file is not used as a module, it will hold the special value None.

__path__

Used as a special variable to hold the path to the module in a package. If the module is not within a package, __path__ is not defined.

__file__

Used as a special variable to hold the name of a Python program file.

__cached__

A special variable often used together with the special variable __file__, referring to a precompiled bytecode. If the precompiled bytecode is not from a program file, __file__ is not defined.

__loader__

Used as a special variable to hold the object that loads or imports the module so that you would know who is using the module.

__doc__

Used as a special variable to hold the documentation of a module or Python program if it is used as the main program, documentation of a class, or function or method of a class.

Dunder names used for special functions and methods will be discussed in Chapter 6 and Chapter 7.

Rules of Scope Resolution for Identifiers

Big programs for complicated applications often use hundreds or even thousands of identifiers to name variables, functions, classes, and other objects. When so many names are used, it is unavoidable that some names will be used more than once. How can we ensure in a program that each name can be mapped to an object without confusion and ambiguity? The answer is to follow the LEGB rule, in which L, E, G, and B refer to different scopes from small to big: L is for local, referring to the inside of a function or class; E is for enclosed, referring to the inside of a function enclosing another function; G is for global, referring to the space outside of all classes and function in a Python program file; and B is for built-in, referring to all the names defined within Python’s built-in module. The relationships of LEGB scopes are illustrated in Figure 2-4.

The illustration above should be viewed in reference to a name used within a function or class. To resolve the name or to link it to a specific object, apply the following LEGB rules:

1. 1. Look at the names defined locally (L) within the function/method or class. If not defined, proceed to the next rule.
2. 2. Check whether the name has been defined in the enclosure (E) function (note that enclosures are not often used, so this is just for discussion right now). If not, proceed to the next rule.
3. 3. Check whether it has been defined globally (G).
4. 4. Check whether it is a built-in (B) name of Python.

The following sample shows how matching local and global names are resolved:

You may have noted in the example above that variable l_name is defined both locally in definition of the function display_names() and globally. When it is used within the function, its local definition is used; variable g_name, on the other hand, is only defined globally, and when it is used within the function, it is resolved to its global definition.

In addition to the LEGB rules, please keep in mind the following:

1. 1. A local name defined in a function will not be seen anywhere outside the function.
2. 2. A local name defined in a class can be seen outside the class or its objects if the name is not a private member of the class, with an explicit reference to the name with dot notation. For example, a name X defined in class C can be accessed using C.X, or O.X if O is an object of C.
3. 3. A name Nx globally defined in a Python script file named M1.py can be seen inside another Python script file by either importing the name explicitly from M or by importing M1 as a whole and using dot notation M1.Nx to access Nx.

Signed Integers (int)

Signed integers in Python are …−2, −1, 0, 1, 2…, as examples. In Python 3, signed integers can be of arbitrary size, at least theoretically, as long as computer memory is not exhausted. In implementation, however, the biggest integer is defined by sys.maxsize, a variable named maxsize in a module called sys, which specifies the maximum number of bytes that can be used to represent an integer number. The notation of sys.maxsize here means maxsize, defined in module sys.

Operations on integer numbers include the following:

• addition (x + y)
• subtraction (x − y)
• multiplication (x * y)
• division (x / y)
• negation (−x)
• exponentiation (x ** y)
• modular (x % y)
• integer division (x // y)

You should be able to use the above operations, which you should already be familiar with, as well as the following bitwise operations you may never have heard about:

• bitwise or (x | y)
• >>> 1 | 4
• 5
• bitwise exclusive or, often called XOR (x ^ y)
• >>> 1 ^ 2
• 3
• bitwise and (x & y)
• >>> 1 & 5
• 1
• shifted left (x << n)
• >>> 2 << 3
• 16
• shifted right (x >> n)
• >>> 256 >> 5
• 8
• invert (~x)
• >>> ~128
• -129

The following are a few more samples from the Python interactive shell that show how these operators are used:

The next few examples are about bitwise operations. The first two operations on the first line show the binary form of the two numbers. In Python, you can have two or multiple statements on a single line, but you are not encouraged to do so.

There are also many built-in functions available for operations on integers. All the built-in functions of Python will be discussed in detail below.

In addition, the following methods are also available to use for operations on integer objects.

n.bit_length()

This returns the number of necessary bits representing the integer in binary, excluding the sign and leading zeros.

n.to_bytes(length, byteorder, *, signed=False)

This returns an array of bytes representing an integer, where length is the length of bytes used to represent the number. byteorder can take Big-Endian or Little-Endian byte order, depending on whether higher-order bytes (also called most significant) bytes come first or lower-order bytes come first, and an optional signed argument is used to tell whether 2’s complement should be used to represent the integer.

Recall that modern computers use 2’s complements to represent negative numbers. So if the integer n is negative while signed remains False, an OverflowError will be raised, as shown below:

So a correct call of the method would be

int.from_bytes(bytes, byteorder, *, signed = False)

This classmethod returns the integer represented by the given array of bytes.

Note that when two bytes are used to represent integer 256, 0b100000000 will be expanded to 00000001 00000000. In Big Endian, it represents 256, but in Little Endian, 00000001 becomes the less significant byte, while 00000000 becomes the most significant byte, and the corresponding number for 256 becomes 00000000 00000001.

For more advanced operations on integers, there are some special modules such as the standard math module, math; the free open-source mathematics software system SAGE; (https://www.sagemath.org/); SymPy (https://www.sympy.org/en/index.html); and, for operations in number theory, eulerlib (https://pypi.org/project/eulerlib/).

Float (float)

Float numbers are numbers with decimals, in the form of 12.5 in decimal notation or 1.25e1 in scientific notation, for example. Operations on float numbers include addition (+), subtraction (−), multiplication (*), division (/), and exponentiation (**), as shown below:

In the example above, the equal sign (=) is an assignment operator in Python (and almost all other programming languages as well). We will explain all operators fully later in this section.

Python can handle very big integers and floating-point numbers. When a number is too big, it becomes difficult to count and check for accuracy. To solve that problem, Python allows using the underscore to separate the numbers, in the similar way that accounting and finance use a comma. The following is an example:

Using an underscore to separate the digits has made it much easier to tell how big the number is.

r.as_integer_ratio()

This returns a pair of integers whose ratio is exactly equal to the original float r and with a positive denominator. It will raise OverflowError on infinities and a ValueError on NaNs.

r.is_integer()

This returns True if r is finite with integral value, and False otherwise.

r.hex()

This returns a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading 0x and a trailing p and exponent.

float.fromhex(s)

This returns the float represented by a hexadecimal string s. The string s may have leading and trailing whitespace.

Boolean (bool)

Boolean data have only two values: True and False. They are used to represent the result of a test or an evaluation of logical expressions, as we will see. Technically, Python does not need a special Boolean data type, since it treats 0 and None as Boolean False, and treats everything else as Boolean True, as shown below:

However, having a Boolean data type with two Boolean values of True and False does clearly remind Python programmers, especially beginners, that there are special types of data and expressions called Boolean data and Boolean expressions.

Complex (complex)

If you have never heard about complex numbers, quickly search the internet for complex numbers and read some articles or watch some videos.

Briefly, a complex number is a representation of a point on a plane with X and Y axes that take the form of x + yj, in which x and y are float numbers that represent and define the location of a point on the plane. Examples of complex numbers are 1 + 1j, 3 − 6j, 2.5 − 8.9j, and so on.

The same operations on float numbers can also be applied to complex numbers, as shown below:

String (str)

Sequences are a group of data in order, and a string is a good example of a sequence.

Like numbers, strings are very important in all programming languages. It is hard to imagine what a number means without its context. For that reason, in most programming languages, strings are also considered a primary data type in terms of their importance and the role that they play.

In Python, strings are sequences of characters, symbols, and numbers enclosed in a pair of double quotation marks or a pair of single quotation marks. Table 2-2 is a list of ASCII characters that can be used in strings. The following are some examples of strings:

When a string is too long and needs to span more than one line, a pair of triple quotation marks can be used, as shown in the following example:

This can be very useful in cases such as when you want to print out instructions for users to use with an application you developed.

Otherwise, you would need to use backslash at the end of each line except the last one to escape the invisible newline ASCII character, as shown below:

This is OK if the string only spans across two or three lines. It will look clumsy if the string spans across a dozen lines.

In the example above, we use backslash \ to escape or cancel the invisible newline ASCII character. In Python and almost all programming languages, some characters have special meanings, or we may want to assign special meaning to a character. To include such a character in a string, you need to use a backslash to escape from its original meaning. The following are some examples:

In the examples above, putting a backslash in front of n assigns the combination \n a special meaning, which is to add a new line to the string; putting a backslash in front of t assigns the combination \t a special meaning, which is to add a tab (a number of whitespaces) to the string. The next example uses backslash to escape the quotation from its original meaning defined in Python.

These 128 ASCII characters, including both printable and unprintable ones, are defined for communication in English between humans and machines. There is an extended set of ASCII characters defined for communication in other Western languages such as German, French, and others.

To enable communication between human and machines in languages such as Chinese, Unicode was designed. Details about Unicode can be found at https://unicode.org/. For information on how Unicode is used in Python, read the article at https://docs.python.org/3/howto/unicode.html.

In earlier versions of Python, if you want to use a non-ASCII character encoded in Unicode in a string, you need to know the code, assuming it is NNNN, and use escape sequence \uNNNN within the string to represent the non-ASCII character. You can also use built-in function chr(M) to get a one-character string encoded in Unicode, where M is code of the character in the Unicode table. The reverse built-in function order(Unicode character) is used to get the code of the Unicode character in the Unicode table.

In Python 3.0, however, the default encoding of Python programs was changed to UTF-8, which includes Unicode, so you can simply include any Unicode character in a string and PVM will recognize and handle it correctly, as shown in the following example:

When representing strings, some prefixes or flags can be put in front of the opening quotation mark. These flags are also called prefixes, used before the opening quote of a string. These prefixes are listed in Table 2-3 with their meaning and some coding samples.

List

List is a very useful compound data type built into Python. A list of elements, which can be different types of data, is enclosed in square brackets. The following are some examples of lists:

In Python, an element in a list can be any type of data or object, to use a more common computer-science term. So an element can be a list too, such as,

Assume that

The term week[0] refers to the first element of the list, and week[1] refers to the second element of the list, where 0 and 1 are called index. An index can be negative as well, meaning an item counted from the end of the list. For example, week[-1] will be Sunday, the first item from the end; week[-2] will be Saturday, the second item from the end.

To get a sublist of a list L we use notation L[s: e], where s is the starting point in the list, e is the ending point within the list, and the sublist will include all items from s till e but excluding the item at e. For example, to get all weekdays from the list week, we use week[0,5], as shown below:

Negative indexing becomes convenient when a list, or any sequence, is too long to count from the beginning. In the example above, it is much easier to count from the end to find out that the weekdays stop right before Saturday, whose index is −2, as shown below:

Within the notation of L[s:e], s or e or both may be missing. When s is missed, it means the sublist is indexed from the beginning of the list; when e is missed, it means the sublist is indexed from the end of the list. So week[:] will include all the items of the list week, as shown below:

Multiple lists can be joined together with operator +. Assume we have the following two lists:

We can then combine weekdays and weekend into one list and assign the new list to week using operator +, as shown below:

A copy of a list can be easily made by sublisting all its members, as shown below:

We can create a list from a string using the built-in function list():

We can also create a list using the built-in function list() and range():

We can use the built-in function len() to find out how many elements are in the list:

Tuple

Tuple is another type of sequence, but members of a tuple are enclosed in parentheses. The following are some sample tuples:

You can create a tuple from a list by using the tuple() function. For example,

tpl = tuple(week)

This will create a tuple, as shown below:

Similarly, you can create a list from a tuple, as shown below:

Members of a tuple can be accessed in the same way as lists because the members are also indexed. For example, tpl[0] refers to Monday.

Moreover, most of the operations used on lists can be applied to tuples, except those that make changes to the member items, because tuples are immutable.

Why are tuples immutable? You may consider it like this: A tuple is used to represent a specific object, such as a point on a line, or even a shape. If any member of the tuple is changed, it will refer to a different object. This is the same for numbers and strings, which are also immutable. If you change any digit of a number, or any character of a string, the number or string will be different.

Set

In Python, a set is a collection of elements or objects enclosed in a pair of curly brackets. Like sets in mathematics, members in a set are unordered and unindexed. The following are two examples of sets:

You can use built-in function set() to build a set from a list or tuple:

Built-in functions set(), list(), tuple(), float(), int(), str() are also called constructors or converters, because they are used to construct or convert to one respective type of data from another type.

You can use membership operator in to test if an object is a member of a set. For example,

will give you a True value because John is a member of set My_friends constructed above.

You can use built-in function len() to get the size of a set—that is, how many members are in the set. So len(grades) will be 12.

Dictionary

In Python, a dictionary is a collection of comma-separated key-value pairs enclosed in curly brackets and separated by a colon :. The members of a dictionary are unordered and unindexed. The following is an example:

Because the keys are used to retrieve the values, each key must be unique within a dictionary. For example, we use Weekday['Mon'] to retrieve its corresponding value, Monday.

In this case, you can also use integer numbers as keys, as shown below:

Object

Although you can code almost any application in Python without object-oriented thinking, you should be aware that Python fully supports object-oriented programming. In fact, Python treats everything as an object, including classes, functions, and modules. For example, numbers are treated as objects in the following statements:

There are some special types of objects in Python, as shown in Table 2-4.

Variables

A variable is a name that identifies a location in computer memory to store data. A variable must conform to the rules of naming discussed earlier in this section, and it also must not be used for other purposes within the same context of the program. For example, you cannot use reserved words or keywords as variables.

An important operation on a variable is to assign a value to it or put a value into the memory location identified by the variable. In Python, this is done by using the assignment operator =.

For example, the following statement assigns COMP 218 to the variable course, assigns Smith to the variable student, and assigns 99 to the variable grade:

Unlike other programming languages, in Python, there is no need to declare its type before a variable is introduced and used in your program for the first time. Its type is determined by the value assigned to it. In the above example, the type of grade is integer, because 99 is an integer.

You may convert the value of a variable into another type using specific built-in functions, such as int(), float(), str(), etc.

Please note that in Jupyter Notebook, if you need a new cell, simply click the plus sign button under the notebook menu.

Please also note that the type of variable area is the same as the type of variable pi, but not of variable r. We can check what type the result will be when a different arithmetic operator is applied to a pair of numbers of the same or different types, as shown in Tables 2-5a and 2-5b:

The following coding example in Jupyter Notebook confirms that the result will be a complex number when an integer is divided by a complex number:

You may copy and modify the code above to check other combinations in Jupyter Notebook.

Built-In Constants

We have seen some values of various data types. Some values have special meanings in Python. We call them constants. The following table lists all the constants you may see and use when programming with Python.

More information about these constants can be found at https://docs.python.org/3/library/constants.html.

Arithmetic Operators

Arithmetic operators are used on numbers. These operators are well-known. Table 2-7 provides a list of these operators, their meaning, and code samples you may take and practise in Python interactive mode. Please copy only the expressions or statements behind >>>, which is the Python prompt for your input.

When two or more of these arithmetic operators are used in an expression, the precedence rules you learned in high school or university math courses apply. In brief, the precedence rules for all the operators are as follows:

1. 1. Exponent operation (*) has the highest precedence.
2. 2. Unary negation (−) is the next.
3. 3. Multiplication (*), division (/), floor division (//), and modulus operation (%) have the same precedence and will be evaluated next unary negation.
4. 4. Addition (+) and subtraction (−) are next, with the same precedence.
5. 5. Comparison operators are next, with the same precedence.
6. 6. The three logical operators (not, and, or) are next, with not having the highest precedence among the three, followed by and, then or.
7. 7. When operators with equal precedence are present, the expression will be evaluated from left to right, hence left association.
8. 8. Parentheses can be used to change the order of evaluation.

The following are some examples of how expressions are evaluated.

In the expression 12 + 3 * 21, because * has higher precedence than +, 3 * 21 is evaluated first to get 63, and then 12 + 63 is evaluated to get 75.

In this example, because ** has the highest precedence, 2 ** 3 is evaluated first, to get

In this intermediate result, because of parentheses, we will need to evaluate ((23 + 32) // 6 − 5 * 7 / 10) first, and in this subexpression, because of parentheses, 23 + 32 will be evaluated first to get 55//6 − 5 * 7 /10. According to the precedence rules, this subexpression will be evaluated to 9 − 35 / 10, and then 9 − 3.5 = 5.5. Then the expression above will be

which is evaluated to be 44.0.

Comparison Operators

Comparison operators are used to compare two objects. It is easy to understand how they work on numbers and even strings. When a comparison is applied to lists or tuples, the comparison will be applied to pairs of items, one from each list or tuple, and the final result is True if there are more Trues; otherwise it will be False, as shown in the example below:

Table 2-8 explains all the comparison operators, with samples.

Logical Operators

Logical operators are used to form logical expressions. Any expression whose value is a Boolean True or False is a logical expression. These will include expressions made of comparison operators discussed above. Table 2-9 summarize the details of these logical variables.

Logical expressions are often used in if and while statements, and it is important to ensure that the logical expressions used in your programs are correctly written. Otherwise, catastrophic results may occur in some real applications. Common errors in writing logical expressions include:

1. 1. Using > instead of <, or using < instead of >
2. 2. Using >= instead of >, or using > instead >=
3. 3. Using <= instead of <, or using < instead <=

For example, suppose you are writing a program to control the furnace at home, and you want to heat the home to 25 degrees Celsius. The code for this should be

However, if instead you wrote,

the consequence would be either the home will not heat at all (if the initial temperature is below 25 when the program starts) or it will overheat (if the initial temperature is greater than 25).

Bitwise Operators

We know that data in computer memory are represented as sequences of bits, which are either 1 or 0. Bitwise operators are used to operate bit sequences bit by bit. These bitwise operations may look strange to you, but you will appreciate these operations when you need them. Table 2-10 provides a summary of bitwise operators. Please note that built-in function bin() converts data into their binary equivalents and returns a string of their binary expressions, with a leading 0b.

Assignment Operators

In Python, and all programming languages, the assignment operation is one of the most important operations because assignment operations store data in variables for later use.

In previous sections, we have seen many examples of using the assignment operator =, the equal sign. However, Python provides many augmented assignment operators. Table 2-11 lists all the assignment operators you can use in your Python programs.

Identity Operators

Identity operators are used to test if two operands, usually two identifiers, are identical, which in most implementations of Python means that they are referring to the same memory block of the computer. The examples Table 2-12 tell you more about this. Note that in the example, the built-in function id(o) is used to get the id of object o.

Sequence Operators

In 2.1, we learned that sequences include strings, lists, and tuples because elements in strings, lists, and tuples are ordered and indexed. Sets and dictionaries are not sequences because elements in dictionaries and sets are not ordered, or not in sequence.

Sequence operators are made available for operations on strings, lists and tuples, as shown in Table 2-13.

Membership Operator

Membership operators are used to test whether an element is a member of a sequence. There are three membership operators in Python, and two of them are shown in Table 2-14.

The third membership operator is used to access members of objects, modules, or packages. It is the dot (.) operator. The example in Table 2-15 shows how to access a function in module math.

Expression Statement

Simply put, expression statements in Python programs are just expressions in mathematical terms. Any expression can be used as a statement, and PVM will evaluate every expression statement, but the result is only displayed in Python interactive mode, as shown in the following code sample in the Python Shell:

So if you are using Python in interactive mode, you can simply type expressions without using the print statement to see the result of the calculation, just like a powerful calculator.

We can also have expression statements in Jupyter Notebook, but when there are several expression statements in the same cell, it will only show the result of the last expression, as shown in the following example:

We mentioned earlier in this subsection that you can also put several simple statements on the same line, but you must separate them with semicolons. This is shown in the following examples:

The expression statement above can also be given in Jupyter Notebook, as shown below. In Jupyter Notebook, however, you have to press Shift+Enter or click the play button to run the scripts in an active cell:

Again, in Jupyter Notebook, even if multiple expression statements are on the same line, only the result of the last expression statement will be displayed.

Assignment Statement

The assignment statement is one of the most important statements and is used most often in programs because it is a common requirement to keep the result of computing or information processing in the computer memory for future uses. It does so by assigning the result to a variable.

In section 2.1, we saw a list of assignment operators. Formally, an assignment statement is made of a variable on the left and an expression on the right of an assignment operator, either = or an augmented one such as +=. We have already seen some examples of assignment statements before, but the following code sample includes a few more examples:

Augmented Assignment

In programming, we often take the value of a variable, perform an operation on it, then put the result back to the variable. That is when augmented assignment comes into play.

In section 2.1, we saw several augmented assignment operators. In general, for an assignment in the form of

the augmented assignment can be used in the following form:

The following are some examples of augmented assignments:

To understand these augmented assignment statements, we need to consider the memory location referred to by a variable, such as y with respect to time. Take y *= n as an example. At time t0 before the actual assignment starts, the value of y (data stored in the memory referred to by y, which is 10 at time t0) is taken out, and multiplied by n, whose value is 5 at time t0; then time t1—the result, which is 50 (from 10 * 5)—is stored in the memory location referred to by variable y.

Multiple Assignments

Also, for convenience and efficiency, you can assign values to multiple variables in a single assignment statement. There are several ways of doing multiple assignments, as shown in the following examples:

In the last example above, *l, *y tells PVM that variable l and y can take a variable-length list of values.

Conditional Assignments

Additionally, in Python, you may even assign different values to a variable under different conditions, as shown in the following example:

As you will see throughout the text, there are many fancy ways of making statements in Python, and that’s why Python is a very powerful language. Indeed, the full power of a programming language can only be materialized by the best programmers.

Annotated Assignment Statement

We know that variables in Python are dynamically typed. Sometimes, however, it is nice to indicate what type of data is expected for a variable. In Python, this is done by annotating the variable using a colon followed by the name of the data type, as shown in the following example:

However, Python will not complain if other types of data are assigned, as shown below:

To annotate the type of value returned from a function, you need to use -> followed by the data type, right before the colon, as shown in the following example:

In this example, marks:float determines that a float number is expected for marks when calling the function, and -> str dictates that a string is to be returned.

It must be made clear that the actual type of a variable is still determined by the value it holds, and annotation added to a variable or function doesn’t really change the type of the variable or the value returned from a function. So annotations are more for programmers as reminders.

print Statement

The print statement is another one of the most important statements. It is used to output (to a terminal by default) so that a program can tell human users the result of calculations or information processing, the value of an object, or the status of the program. The following are some examples of print statements:

The print statement can evaluate multiple arguments and print out the values. If the arguments are all constant strings, there will be no need to separate them into multiple arguments. Separate arguments are needed only when some arguments are expressions, like the round(300/110) in the above example. If you do not like separations, introduced in release 3.0, Python provides a neat way to include expressions all in a single pair of quotation marks, as shown in the following example:

Please note the f—which is a flag or prefix—before the opening quotation mark and the curly brackets around the expression. Without the f flag, everything will be taken literally as part of the string, without evaluation.

If you want one portion of the string to be put on one line and the other portion on the next line, you may insert \n between the two portions in the string, as below:

In addition to \n, other escape sequences that we discussed previously may also be included in a string.

There may be times that you want to include an escape sequence such as \n in a string as is. To achieve that effect, you either use the r flag before the opening double quotation mark or use another backslash \ before the escape sequence to cancel the first backslash (escape), as shown in the following example:

Without the r flag, the sentence will be printed on two lines, as shown in the following example:

Normally, a \n (newline) will be automatically appended to the output from each print statement by default, so that the output from the next print statement will print on a new line. If you want the output from a print statement to end with something else rather than a new line, you may use the end keyword argument to specify how the output should be ended. In the following example, output from the first print statement will be ended with a whitespace, so that outputs from the two print statements will be on the same line:

Formally, a print statement may take the following form when used:

where value0, value1,… are values to be printed to a file stream; optional keyword argument sep defines what is used to separate value0, value1,…; optional keyword argument end tells how the output from the print statement should end; optional keyword argument file defines what file stream the output should be printed on; and optional keyword argument flush tells how the output should be flushed. The meanings and purposes of these optional keyword arguments are explained in Table 2-16.

Please note that a program may need to output different types of data not only correctly but also nicely. In 5.1, we will learn how to construct well-formulated strings from various types of data.

input Statement

The input statement is another important one you must learn and use correctly and effectively. Contrary to the print statement, the input statement is used to get information from users through the keyboard, as shown in the following example in Jupyter Notebook:

Please note that everything taken from users through the input statement is treated as a string. If you are expecting a number, such as an integer, you must convert the string into its respective data type, as shown in the following example:

As you may have guessed already, the input statement takes one argument as a prompt to tell users what to do and what the program is expecting from the user.

If you want to provide more detailed instructions in the prompt to the user, you may use the triple quotation marks to include multiple lines of instruction as prompt:

As you can see, this can be a good way to make a menu for some terminal-based applications.

assert Statement

The assert statement is used to test if a condition is true in a program. It may take one of two forms, as shown in Table 2-17.

The assertion statement is very useful in debugging your programs, because it can be used to check the value of a variable or a certain condition of the program. If the condition is not met as expected, the program would stop and let you check what’s going on, as shown in the following examples:

pass Statement

As the name implies, this statement does nothing. It is used as a placeholder in places where you don’t have the actual code yet. As an example, assume you have the class Student in your design for a project, but the implementation details of the class, except the name, are yet to be worked out. You can use the pass statement to hold the place of the details, as shown below:

With the pass statement in place, this piece of code can run as part of a big program without raising an exception.

Note that a pass statement won’t let you get out of a loop. You will need to use the break statement to get out of a loop.

del Statement

This statement is used to delete an object. Because Python treats everything as an object, you can use this statement to delete everything you’ve defined.

Deleting an object will free up the memory locations occupied by the object. Computer memory is a precious resource in computing. Python objects, even objects of built-in data types—such as list, tuple, set, and dictionary—can take up a great deal of memory. Deleting the objects that are no longer used will free up memory and make it available for other objects and other applications.

return Statement

The return statement is one of the most important statements in Python (and some other languages as well). It is used to return a value from a function—a very important construct of all programs. The following is an example:

This function simply takes a number and returns n to the power of 3.

Please note that in Python, the return statement doesn’t have parentheses around the value to be returned. Even if you want to return multiple values from a function, you only need to use commas to separate the values behind the return keyword. The return statement will automatically pack all the values in a tuple and then return them.

In the following example, we define a function of a modular operation but return the quotient and the remainder at the same time:

open Statement

The open statement is used to open a file for writing, reading, appending, or updating (reading and writing). The following is an example:

This opens the file specified by c:\\workbench\\myprimes.txt and creates a file object ready for reading. Reading is the default mode when you open a file without the second argument. Hence the following statement does the same as the above statement:

To open a file for writing, w is used for the second argument:

When a file is opened for writing, the old data will be overwritten if there is already data in the file. To keep the old data and append new data to the file, use a for the second argument instead:

If you want to create a file only if the file doesn’t exist, use x for the second argument, to mean exclusive creation of the file:

This would avoid accidentally overwriting a file.

By default, data written to a file opened with w, a, or x is text. The data on a file can also be in binary format. To explicitly indicate whether data on a file are or should be text or binary, you can use t or b with r, w, a, or x, as shown in the following examples:

yield Statement

The yield statement is used in place of the return statement in some special circumstances when defining a function. When the yield statement is used in defining a function, the function becomes a generator in Python terms, as shown in the following example:

When we say a function becomes a generator, we mean that an object of the generator class is returned from the function.

What is a generator object? For now, you may consider it a dynamic list whose members are generated and used dynamically on the fly, without using a big bunch of memory to store the whole list. The following is an example of a generator:

If we run

we will see the following members:

• 0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728,

However, if we try to get the length of the generator object with the following statement:

we will get the following error:

TypeError: object of type 'generator' has no len()

This confirms that an object of type generator has no length.

raise Statement

When some errors occur in a Python program, exceptions will be automatically raised and the program will stop running, unless the exception is handled with the try-except statement. Such errors include operations deemed illegal by Python. In some cases, an exception needs to be explicitly applied when a certain condition is met. In the previous section, we saw how an exception can be raised with the assert statement. In the following example, we show how to raise an exception with the raise statement.

This piece of code is used to calculate the average marks of 39 students, but it considers a negative mark unacceptable and will raise an exception.

break Statement

The break statement is used to get out of a loop and continue to the next statement. Here is an example: