OAU CSC 201 Practice Quiz

The code shown above prints the appropriate option depending on the conditions given. The condition which matches is (9>0), and hence the output is: good.

The expression not(-6<0 or -6>10) returns the output False.
The expression -6>=0 and -6<=10 returns the output False.
The expression not(-6<10 or -6==10) returns the output False.
The expression not(-6>10 or -6==10) returns the output True.

In the code shown above, the function mk() is the decorator. The function which is getting decorated is mk2(). The return function is given the name p().

The else part is not executed if control breaks out of the loop.

The elements of the tuple are accessed by their indices.

The code ‘There are %d %s birds.’ %(4, blue) results in the output: There are 4 blue birds. When we insert more than one value, we should group the values on the right in a tuple.

The expression shown above is an example of explicit conversion. It is evaluated as int(43.55+1) = int(44.55) = 44. Hence the result of this expression is 44.

The code shown above prints the values substituted for p and q in the same order. Note that there is no blank space between p and q. Hence the output is: sanfoundry.

Explanation: { } creates a dictionary not a set. Only set() creates an empty set.

The @ symbol can be used as an alternate way to specify a function that needs to be decorated. The output of the codes shown above is the same. Hence they are equivalent. Therefore this statement is true.

~x is equivalent to -(x+1).
~~x = – (-(x+1) + 1) = (x+1) – 1 = x
~~x is equivalent to x
Extrapolating further ~~~~~~x would be same as x in the final result.
In the question, x value is given as 5 and “~” is repeated 6 times. So, the correct answer for “~~~~~~5” is 5.

9 isn’t allowed in an octal number.

We can simply convert strings with a %s format expression or the str built-in function. Both of these methods have been shown in this code. Hence the output is: ) (‘3.3456789’, ‘3.3456789’)

Objects of type int have no attribute upper().

i is not in x[1:].

The string x is being shortened by one character in each iteration.

Here, ‘result’ is a list which is extending three times. When first time ‘extend’ function is called for ‘result’, the inner code generates a generator object, which is further used in ‘extend’ function. This generator object contains the values which are in ‘list1’ only (not in ‘list2’ and ‘list3’).
Same is happening in second and third call of ‘extend’ function in these generator object contains values only in ‘list2’ and ‘list3’ respectively.
So, ‘result’ variable will contain elements which are only in one list (not more than 1 list).

The expression int(1011,2) results in an error. Had we written this expression as int(‘1011’,2), then there would not be an error.

The function seed is a function which is present in the random module. The functions sqrt and factorial are a part of the math module. The print function is a built-in function which prints a value directly to the system output.

As the value of i or x isn’t changing, the condition will always evaluate to True.

Execute help(round) in the shell to get details of the parameters that are passed into the round function.

The symbol ‘&’ represents bitwise AND. This gives 1 if both the bits are equal to 1, else it gives 0. The binary form of 15 is 1111 and that of 12 is 1100. Hence on performing the bitwise AND operation, we get 1100, which is equal to 12.

+’ cannot be converted to a float.

List data type can store any values within it.

Objects of type set have no attribute values.

Loops over key, value pairs.

The one’s complement of a value is obtained by simply changing all the 1’s to 0’s and all the 0’s to 1’s. Hence the one’s complement of 110010101 is 001101010.

The output of the expression above will be 22.19. This expression specifies that the total number of digits (including the decimal point) should be 5, rounded off to two decimal places.

The code shown above shows a general decorator which can work with any number of arguments.

Variable names can be of any length.

The binary form of 1 is 0001. The expression x<<2 implies we are performing bitwise left shift on x. This shift yields the value: 0100, which is the binary form of the number 4.

Execute in the shell.

Functions are reusable pieces of programs. They allow you to give a name to a block of statements, allowing you to run that block using the specified name anywhere in your program and any number of times.

Pickling is the process of serializing a Python object, that is, conversion of a Python object hierarchy into a byte stream. The reverse of this process is known as unpickling.

In most cases the value of two’s complement is different from the original value. However, there are cases in which the two’s complement value may be equal to the original value. For example, the two’s complement of 10000000 is also equal to 10000000. Hence the statement is false.

The built in function vars() returns a dictionary containing all the variables that exist in the place. Hence the output of the code shown above is: {‘a’ : ‘hello’, ‘q’ : 10, ……..plus built-in names set by Python….}

The same object is modified in the function.

Let’s break this down step by step so that it’s clear.

Code Analysis:

The Function:

def foo(x):

    x[0] = [‘def’]  # Changes the first element of the list `x` to [‘def’]

    x[1] = [‘abc’]  # Changes the second element of the list `x` to [‘abc’]

    return id(x)    # Returns the memory address (ID) of the modified list `x`

The Main Code:

q = [‘abc’, ‘def’]          # Creates a list `q` with two elements: [‘abc’, ‘def’]

print(id(q) == foo(q))      # Compares the memory address (ID) of `q` with the value returned by `foo(q)`

Step-by-Step Explanation:

1. List q Initialization:

• A list q is created:

q = [‘abc’, ‘def’]

• This list has an ID, which is its memory address. Let’s call it id(q).

2. Calling foo(q):

• The list q is passed into the function foo.

• Inside foo:

• x[0] = [‘def’]: The first element of the list is changed to [‘def’].

Now, q looks like this:

[[‘def’], ‘def’]

• x[1] = [‘abc’]: The second element of the list is changed to [‘abc’].

Now, q looks like this:

[[‘def’], [‘abc’]]

• The id(x) is returned. Since x and q refer to the same list, id(x) is the same as id(q).

3. Comparison (id(q) == foo(q)):

• The memory address of q is compared to the memory address returned by foo(q).

• Since foo(q) does not create a new list but modifies the same list, id(q) and id(x) are identical.

Output:

True

Key Points to Understand:

1. Lists are mutable: When you pass a list to a function, any changes made to the list inside the function will affect the original list because they share the same memory address.

2. The id() function: This returns the memory address of an object.

True, False and None are capitalized while the others are in lower case.

Each object in Python has a unique id. The id() function returns the object’s id.

The expression shown above results in the output 456.

The expression shown above rounds off the given number to the number of decimal places specified. Since the expression given specifies rounding off to two decimal places, the output of this expression will be 56.24. Had the value been x=56.234 (last digit being any number less than 5), the output would have been 56.23.

SyntaxError, there shouldn’t be a space between + and = in +=.

The line of code shown above can be simplified to state that ‘hello’ should be printed if the argument passed to the Boolean function amounts to zero, else ‘morning’ will be printed.

Any odd number on being AND-ed with 1 always gives 1. Any even number on being AND-ed with this value always gives 0.

The formatting expression accepts either a single substitution value, or a tuple of one or more items. Since single item can be given either by itself or within the tuple, a tuple to be formatted must be provided as a tested tuple. Hence the output of the code is: >>> ‘%s’ %((1.23,),).

Here i i i i i … printed continuously because as the value of i or x isn’t changing, the condition will always evaluate to True. But also here we use a citation marks on “i”, so, here i treated as a string, not like a variable.

All of the operators shown above have associativity from left to right, except exponentiation operator (**) which has its associativity from right to left.