Final

Question 1

Accumulator

Answer 1

An accumulator is a fancy name for a variable in a for-loop that stores information computed in the for-loop and which will be still available when the for-loop is complete.
Example: In the for loop
total = 0
for x in range(5):
| total = total + x
the variable total is an accumulator. It stores the sum of the values 0..4.

Question 2

Assert Statement

Answer 2

A statement in the form of
assert <boolean> or
assert <boolean expression, string expression>
If the boolean expression is true, an assert statement does nothing. If it is false, it produces an error, stopping the entire program. In the second version of assert, it uses the string expression after the comma as its error message.</boolean>

Question 3

Attribute

Answer 3

Attributes are variables that are stored inside of an object.
It is impossible to enforce invariants on attributes as any value can be stored in an attribute at any time.
Therefore, we prefer to make attributes hidden (by starting their name with an underscore), and replacing them with getters and setters.

Question 4

Instance Attributes

Answer 4

Instance attributes belong to an object or instance. Instance attributes are created by assignment statement that prefaces the object name before the period. They are typically created in the class initializer.

Question 5

Class Attributes

Answer 5

Class attributes belong to the class. They are created by an assignment statement that prefaces the class name before the period. They are also created by any assignment statement in the class definition that is outside of a method definition.

Question 6

Bottom Up Rule

Answer 6

This is the rule by which Python determines which attribute or method definition to use (when the attribute is used in an expression, or the method is called). It first looks in the object folder.
If it cannot find it there, it moves to the class folder for this object. It then follows the arrows from child class to parent class until it finds it. If Python reaches the folder for object (the superest class of all) and still cannot find it, it raises an error.
If the attribute or method is in multiple folders, it uses the first one that it finds.

Question 7

Call Frame

Answer 7

A call frame is a formal representation of that Python uses when you execute a function call. It contains the name of the function as well as all parameters and local variables. It has also an instruction counter that tracks the next line in the function that is to be executed. A call frame is deleted (e.g. erased) as soon as the call completes.

Question 8

Call Stack

Answer 8

The call stack is all of the call frames of the currently executing function calls (e.g. the main function call and all of its helper functions). These call frames are arranged in a stack, with the original function up top, and the most recent function call at the bottom. If the current function calls a helper function, you add a new frame to the bottom. When a helper function completes, you remove the call frame from the stack.

Question 9

Class

Answer 9

A class is any type that is not built-in to Python (unlike int, float, bool, and str which are built-in). A value of this type is called an object.

Question 10

Class Definition

Answer 10

This is a template or blueprint for the objects (or instances) of the class. A class defines the components of each object of the class. All objects of the class have the same components, meaning they have the same attributes and methods. The only difference between objects is the values of their attributes.
Using the blueprint analogy, while many houses (objects) can be built from the same blueprint, they may differ in color of rooms, wallpaper, and so on.

In Python, class definitions have the following form:
class <classname>(<superclass>):
<class>
<getters>
<initializer>
<method>
In most cases, we use the built-in class object as the super clas</method></initializer></getters></class></superclass></classname>

Question 11

Constructor

Answer 11

A constructor is a function that creates a object for a class. It puts the object in heap space, and returns the name of the object (e.g. the folder name) so you can store it in a variable. A constructor has the same name as the type of the object you wish to create.

When called, the constructor does the following:
* It creates a new object (folder) of the class, which is empty.
* It puts the folder into heap space.
* It executes the initializer method __init__ defined in the body of the class. In doing so, it
– Passes the folder name to that parameter self
– Passes the other arguments in order
– Executes the commands in the body of __init__
* When done with __init__ it returns the object (folder) name as final value of expression.
There are no return statements in the body of __init__; Python handles this for you
automatically.

Question 12

Default Argument

Answer 12

A default argument is a value that is given to a parameter if the user calling the function or method does not provide that parameter. A default argument is specified by wording the parameter as an assignment in the function header. Once you provide a default argument for a parameter, all parameters following it in the header must also have default arguments.

Question 13

Encapsulation

Answer 13

Encapsulation is the process of hiding parts of your data and implementation from users that do not need access to that parts of your code. This includes restricting access to attributes via getters and setters, but it also includes the usage of hidden methods as well. This process makes it easier for you to make changes in your own code without breaking the code of anyone who is using your class. See the definitions of interface and implementation.

Question 14

Exception

Answer 14

An exception is an object that stores the stack trace and and error message for when Python crashes. You can create an exception object by calling its constructor, but that will not crash Python. To crash Python, you must combine the exception with a raise statement.

Question 15

Getter

Answer 15

A getter is a special method that returns the value of an instance attribute (of the same name) when called. It allows the user to access the attribute without giving the user permission to change it. It is an important part of encapsulation.

Question 16

Generator

Answer 16

A generator is a special kind of function for creating an iterable. It is defined by placing a yield statement inside the function body. Calling a generator function returns an iterable object that uses this body to produce its elements. You call the next function to iterate through these elements. For example,
for the generator.

Question 17

Global Space

Answer 17

Global space is area of memory that stores any variable that is not defined in the body of a function. These variables include both function names and modules names, though it can include variables with more traditional values. Variables in global space remain until you explicitly erase them or until you quit Python.

Question 18

The Heap

Answer 18

The heap or heap space is the area of memory that stores mutable objects (e.g. folders). It also stores function definitions, the contents of modules imported with the import command, as well as class folders. Folders in the heap remain until you explicitly erase them or until you quit Python. You cannot access the heap directly. You access them with variables in global space or in a call frame that contain the name of the object in heap space.

Question 19

Immutable Attribute

Answer 19

An immutable attribute is a hidden attribute that has a getter, but no setter. This implies that a user it not allowed to alter the value of this attribute. It is an important part of encapsulation.

Question 20

Implementation

Answer 20

An implementation is a collection of Python code for a function, module, or class)
that satisfies a specification. This code may be changed at any time as long as it continues to satisfy the specification.

In the case of a function, the implementation is limited to the function body. In the case of a class, the implementation includes the bodies of all methods as well as any hidden attributes or methods. The implementation for a module is similar to that of a class

Question 21

Inheritance

Answer 21

Inheritance is the process by which an object can have a method or attribute even if that method or attribute was not explicitly mentioned in the class definition. If the class is a subclass, then any method or attribute is inherited from the superclass.

Question 22

Interface

Answer 22

The interface is the information that another user needs to know to use a Python feature, such as a function, module, or class. The simplest definition for this is any information displayed by the help() function.

For a function, the interface is typically the specification and the function header. For a class, the interface is typically the class specification as well as the list of all unhidden methods and their specifications. The interface for a module is similar to that of a class.

Question 23

Instance

Answer 23

This is a synonym for an object. An object is an instance of a class.

Question 24

Invariant

Answer 24

An invariant is a statement about an attribute that must always be true. It can be like a precondition, in that prevents certain types of values from being assigned to the attribute. It can also be a relationship between multiple attributes, requiring that when one attribute is altered, the other attributes must be altered to match.

Question 25

is.

Answer 25

The is operator works like == except that it compares folder names, not contents. The meaning of the operator is can never be changed. This is different from ==, whose meaning is determined by the special operator method __eq__. If == is used on an object that does not have a definition for method __eq__, then == and is are the same.

Question 26

isinstance

Answer 26

The function call isinstance(ob,C) returns True if object ob is an instance of class C. This is different than testing the type of an object, as it will return True even if the type of ob is a subclass of C.

Question 27

Iterable

Answer 27

An iterable type is the type of any value that may be used in a for-loop. Examples include lists string, and dictionaries.

Question 28

Iterator

Answer 28

An iterator is an iterable that may only be used once inside of a for-loop. Once it is used, you have to recreated if you want to use it a second time. You can also use the function next to step through the elements one at a time. Files and web pages are examples of iterators in Python.

Question 29

List

Answer 29

A list is a mutable sequence that can hold values of any type. Lists are represented as a sequence of values in square braces (e.g. [a1, a2, . . . , an]). A list can also hold other lists as well; this is how Python represents mutli-dimensional lists and matrices. For example, [[1,2],[3,4]] is a 2x2 list in Python.

Question 30

Method

Answer 30

Methods are functions that are stored inside of an object. They are define just like a function is defined, except that they are (indented) inside-of a class definition.

Methods are called by placing the object variable and a dot before the function name. The object before the dot is passed to the method definition as the argument self. Hence all method definitions must have at
least one parameter.

Question 31

Object

Answer 31

An object is a value whose type is a class. Objects typically contain attributes, which are variables inside of the object which can potentially be modified. In addition, objects often have methods, which are functions that are stored inside of the object.

Question 32

Operator Overloading

Answer 32

Operator overloading is the means by which Python evaluates the various operator symbols, such as +, *, /, and the like. The name refers to the fact that an operator can have many different “meanings” and the correct meaning depends on the type of the objects involved.

In this case, Python looks at the class or type of the object on the left. If it is a built-in type, it uses the built-in meaning for that type. Otherwise, it looks for the associated special method (beginning and ending with double underscores) in the class definition.

Question 33

Overriding a Method

Answer 33

In a subclass, one can redefine a method that was defined in a superclass. This is called overriding the method. In general, the overriding method is called. To call an overridden method method of the superclass, use the super function as follows.
super().method(…) where method is the name of the method being overridden.

Question 34

Raise Statement

Answer 34

A raise statement a statement of the form
raise exception where exception is a expression for an exception object (e.g. either a constructor call to make a new exception, or a variable storing an existing exception). The raise statement immediately crashes Python and stores the current stack trace in the exception object.

Question 35

Scope

Answer 35

The scope of a variable name is the set of places in which it can be referenced. Global variables may be referenced by any function that which is either defined in the same module as the global variable, or which imports that module. The scope of a parameter or local variable is the body of the function in which it is defined. We do not worry about the scope of attributes for right now.

Question 36

Sequence

Answer 36

A sequence is a type that represents a fix-length list of values. Examples of sequences are lists, strings, and tuples.

Question 37

Setter

Answer 37

A setter is a special method that can change the value of an instance attribute (of the same name) when called. The purpose of the setter is to enforce any invariants. The docstring of the setter typically mentions the invariants as a precondition.

Question 38

Specification, Class

Answer 38

A class specification is description of the purpose of a class and how to use it. A
class specification typically describes what entity the class is supposed to represent. Class specifications are often written using docstrings and include the class invariant.

Question 39

Specification, Function (or Method)

Answer 39

A function specification is a description of what a function should do. It should include (1) preconditions on the arguments, (2) the return value of the function (if it is a fruitful
function, and any other details on what the function does. A function specification is typically written as a docstring comment.

Question 40

Statement

Answer 40

A statement is a command for Python to do something. We have seen the following five
statements so far: assignment statements, return statements, assert statements, conditional-statements, and try-except statements. In addition, any procedure may be used as a statement.

Question 41

Subclass

Answer 41

A subclass D is a class that extends another class C. This means that an instance of D inherits (has) all the attributes and methods that an instance of C has, in addition to the ones declared in D. In Python, every user-defined class must extend some other class. If you do not explicitly wish to extend another class, you should extend the built-in class called object (not to be confused with an object, which is an instance of a class). The built-in class object provides all of the special methods that begin and end with double underscores.

Question 42

Tuple

Answer 42

A tuple is identical to a list except that it is immutable. The contents cannot be removed, expanded, or otherwise altered. Tuples are represented as a sequence of values in parentheses.

Question 43

Try Except Statement

Answer 43

This is a statement of the form
try:
<statements>
except:
<statements>
Python executes all of the statements underneath try. If there is no error, then Python does nothing and skips over all the statements underneath except. However, if Python crashes while inside the try portion, it recovers and jumps over to except, where it executes all the statements underneath there.</statements></statements>

Question 44

Type

Answer 44

A type is a set of values and the operations on them. The basic types are types int, float, bool,
and str. The type list is like str, except that its contents are mutable.

Question 45

Variable

Answer 45

Depending on how you wish to think about it, a variable is a name with associated value or a
named box that can contain a value. We change the contents of a variable via an assignment statement. A variable is created when it is assigned for the first time. We have seen four types of variables in this class: global variables, local variables, parameters, and attributes.

Question 46

Yield Statement

Answer 46

A yield statement is a statement which temporarily pauses the execution of a generator. It produces the next value in the iterator associated with the generator.