Assignment 1

REPL stands for Read, Evaluate, Print Loop. It is a programming environment with its own memory space and can evaluate single or multiple lines of code and produce output. It is an interactive environment where the programmer can try out lines of code one at a time and examine the results before proceeding. One disadvantage of REPL is that it does not save the code in a file for subsequent use, although it can read and execute code that is already written in a file. But that takes away the interactive nature of a REPL and a code editor is much better suited to execute code in a file.

Other programming languages that offer a REPL are Matlab, Julia, Javascript (Node JS) and many more.

In the REPL, value of an object can be displayed by typing the name of the object and pressing Enter or by using the print() function.

>>> a = 10
>>> a
10
>>> print(a)
10

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> basket
{'pear', 'banana', 'orange', 'apple'}
>>> len(basket)
4
>>> 'apple' in basket
True
>>> basket[0]
Traceback (most recent call last):
File "<python-input-15>", line 1, in <module>
    basket[0]
    ~~~~~~^^^
TypeError: 'set' object is not subscriptable
>>> c = basket.union(b2)
>>> c
{'pear', 'banana', 'grapes', 'apple', 'orange'}
>>> basket - b2
{'pear', 'banana', 'orange'}
>>> b2 - basket
{'grapes'}
>>> basket + b2
Traceback (most recent call last):
File "<python-input-23>", line 1, in <module>
    basket + b2
    ~~~~~~~^~~~
TypeError: unsupported operand type(s) for +: 'set' and 'set'
>>> d = {"apple", "Apple"}
>>> d
{'Apple', 'apple'}

1. Order of the elements may not be in the same order as in the defnition of the set
2. Elements of a set cannot be accessed by indexing
3. It is possible to check if a value is contained in the set using the in operator
4. Union of two sets can be obtained using the method set.union(aother_set). Using the + operator to find the union of two sets results in an error
5. Difference between two sets is obtained using the - operator set1 - set2 returns the values of set1 that are not present in set2

Correct answer: D Explanation: The slice is defined by start index = 1, stop index = 4 (but 4 not included) with step size = 1. Thus the indices are 1, 2, 3 and the elements are a[1], a[2], a[3], anmely [20, 30, 40]

>>> a = [10, 20, 30, 40, 50]
>>> a[1:4]
[20, 30, 40]

Correct answer: A Explanation: The operation Item assignment is not allowed because tuple is immutable. However, making a copy of an existing tuple and combining it with another to create a new tuple gives an ppearance that a tuple is mutable.

>>> a = (1, 2, 3)
>>> a[0] = 10
Traceback (most recent call last):
  File "<python-input-32>", line 1, in <module>
    a[0] = 10
    ~^^^
TypeError: 'tuple' object does not support item assignment
>>> a[::2]
(1, 3)
>>> a[2]
3
>>> b = (4, 5)
>>> c = a + b
>>> c
(1, 2, 3, 4, 5)

Correct answer: A Explanation: The items of the tuple ar 1, 2 and (3, 4).

Correct Answer: D Explanation: Only list is mutable, the rest are immutable. Here is an exercise that wil clarify how an int is immutable.

>>> x = 10
>>> id(x)
93827280581664
>>> id(10)
93827280581664
>>> y = x
>>> id(y)
93827280581664
>>> x = 20
>>> id(x)
93827280581984
>>> id(20)
93827280581984
>>> id(y)
93827280581664
>>> z = 20
>>> id(z)
93827280581984

1. Like the variable (object) x, an integer constant such as 10 also has a memory address
2. y = x makes y an alternate name for x and have the same memory address as the integer 10
3. x = 20 creates a new integer 20 at a new memory adress and that address is assigned to x. But the memory address of y remains unchanged to the memory address of 10.
4. z = 20 creates a new variable z and is assigned the memory address that already contains the value 20
5. Integers 10 and 20 are immutable, once created their value stored in a specific memory address does not change

>>> ('a', 'b') + ('c',)
('a', 'b', 'c')`

('c',) is a tuple containing a single element and when added to the tuple with two elements ('a', 'b') returns a new tuple with three elements. If the comma (,) after c is missed, ('')is not atuple` and the operation would result in an error.

>>> ('a', 'b') + ('c')
Traceback (most recent call last):
File "<python-input-12>", line 1, in <module>
    ('a', 'b') + ('c')
    ~~~~~~~~~~~^~~~~~~
TypeError: can only concatenate tuple (not "str") to tupl

True

REPL is a complete Python environment with the built-in Python interpreter, memory space and memory manager. As you type in each command, REPL will interpret your commands and if valid, carry them out. Carrying out a command may involve creating objects in memory, importing modules from an external source and store in memory for later use, compile a function and store it in memory and make it available for subsequent use.

>>> import math
>>> math
<module 'math' (built-in)>
id(math)
140734448557632
>>> def dbl(x):
...     return 2 * x
...     
>>> dbl
<function dbl at 0x7fff4ad09220>
>>> id(dbl)
140734448570912

True

REPL has a built-in interpreter and has it logic for interpreting the commands typed atthe prompt. When the user types the name of an object, the interpreter is programmed to print the corresponding value of the object.

But when the name of an object apperas all by itself in script, becuase it is not assigned to any other object or not used in any other way, that line does not result in any output. In a script, one must use the print() function to display values.

True

True

True

False

True

>>> 'This isn\'t difficult'
"This isn't difficult"
>>> print('This isn\'t difficult')
This isn't difficult

Note that the REPL normally delimits the string by single quotes (') when you type the object or the name of an object. But when the string contains single quotes within it, it delimits the string by double quotes (").

When the string is displayed using the print() function, no quotes are shown in the REPL.

True

Using the index of an element returns a single object of the same type as that of the returned object.

Using the slicing operation returns a list with the objects as defined in the slice.

>>> a = [1, 2, 3, 4, 5]
>>> type(a[0]), a[0]
(<class 'int'>, 1)
>>> type(a[::2]), a[::2]
(<class 'list'>, [1, 3, 5])

If you observe, you will notice that typing more than one object in the REPL command promt, separated commas returns a tuple with the values of the objects typed at the command prompt.