OAU CSC 201 Practice Quiz

The code shown above uses multiple decorators. The output of this code is:

    *****
    %%%%%
    hello
    %%%%%
    *****

The result of the expression shown will be 1011. This is because we have not specified the base in this expression. Hence it automatically takes the base as 10.

The code shown above converts the given arguments to hexadecimal and decimal values and prints the result. This is done using the format specifiers %x and %d respectively. Hence the output of the code shown above is: ‘ff, 255’.

The expression shown above normally returns the value with 6 decimal points if it is not specified with any number. Hence the output of this expression will be: 34.000000 (6 decimal points).

Id in this case will be the attribute of the instance.

Within the subject string, curly braces represent substitution targets and arguments to be inserted. Hence the output of the code shown above:
‘hello, world, universe’.

Identifiers can be of any length.

he binary form of the number 29 is 11101. Hence the output of this expression is ‘0b11101’.

// is the operator for truncation division. It is called so because it returns only the integer part of the quotient, truncating the decimal part. For example: 20//3 = 6.

The line of code can be translated to state that ‘f’ is printed if the argument passed to the Boolean function amount to zero. Else ‘t’ is printed. The argument given to the Boolean function in the above case is ‘spam’, which does not amount to zero. Hence the output is t.

Carefully look at the colons.

Variable names can be of any length.

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.

In the code shown above, various formatting options are displayed using the format option. Hence the output of this code is: ‘1.234560, 1.234560, 01.23’

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

Loops over the elements of the set and prints them.

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.

The code shown above prints 1234 for the format specified %d, ‘1234  ’ for the format specifier %-6d (minus ‘-‘ sign signifies left justification), and 001234 for the format specifier %06d. Hence the output of this code is: ‘integers:…1234…1234  …001234’

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.

A folder of python programs is called as a package of modules.

All of the above examples show explicit conversion. However the expression int(’10.8’) results in an error.

The function not returns true if the argument amounts to false, and false if the argument amounts to true. Hence the first function returns false, and the second function returns false.

The code shown above is used to swap the contents of two memory locations using bitwise X0R operator. Hence the output of the code shown above is: 20 10.

SyntaxError, True is a keyword and it’s value cannot be changed.

The expression shown above does not result in an error. The output of this expression is -%5d0 989. Hence this statement is incorrect.

The code shown above returns the number of times a given function has been called. Hence the output of this code is: 3

The above expression is an example of explicit conversion. It is evaluated as: float(4+int(2.39)%2) = float(4+2%2) = float(4+0) = 4.0. Hence the result of this expression is 4.0.

The code shown first adds the element ‘san’ to the set z. The set z is then updated and two more elements, namely, ‘p’ and ‘q’ are added to it. Hence the output is: {‘a’, ‘b’, ‘c’, ‘p’, ‘q’, ‘san’}

Let’s break it down step by step:

Code:

z = set(‘abc’)                        # Create a set with elements from the string ‘abc’

z.add(‘san’)                          # Add the string ‘san’ to the set

z.update(set([‘p’, ‘q’]))             # Add elements ‘p’ and ‘q’ from another set to `z`

z                                     # Display the final set

Step-by-Step Explanation:

Step 1: Create a set

z = set(‘abc’)

• The string ‘abc’ is turned into a set of individual characters:

z = {‘a’, ‘b’, ‘c’}

• Note: Sets do not allow duplicate elements, so each character in ‘abc’ is added only once.

Step 2: Add the string ‘san’

z.add(‘san’)

• The .add() method adds a single element to the set.

• ‘san’ is treated as a single item, not split into characters.

• The set now looks like this:

z = {‘a’, ‘b’, ‘c’, ‘san’}

Step 3: Update the set with set([‘p’, ‘q’])

z.update(set([‘p’, ‘q’]))

• The .update() method adds multiple elements from another set or iterable to the set.

• The elements ‘p’ and ‘q’ are added individually to z.

• The set now looks like this:

z = {‘a’, ‘b’, ‘c’, ‘san’, ‘p’, ‘q’}

Step 4: Display the set

z

• The set contains all unique elements added in previous steps:

{‘a’, ‘b’, ‘c’, ‘san’, ‘p’, ‘q’}

Important Notes:

1. Sets do not allow duplicate values: If an element already exists, adding it again has no effect.

2. Order of elements in a set is unpredictable: Sets are unordered collections, so the display order might differ.

Correct Answer:

c) {‘a’, ‘b’, ‘c’, ‘p’, ‘q’, ‘san’}

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,),).

The expression int(‘1111’,2) gives the result 15. The expression int(‘1111’, 10) will give the result 1111.

The above expressions are evaluated as: 2/2, 8/2, which is equal to (1.0, 4.0).

Class is a user defined data type.

In order to add ‘n’ blank spaces after a given string ‘S’, we use the formatting option:(“%-ns”%S).

The expressions are evaluated as: 4%3 and 6//2 respectively. This results in the answer (1,3). This is because the associativity of both of the expressions shown above is left to right.

The binary value of 0x35 is 110101 and that of 0x75 is 1110101. On OR-ing these two values we get the output as: 1110101, which is equal to 117. Hence the result of the above expression is 117.

Variable x is incremented and printed twice.

NameError, i is not defined.

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

Neither of 0.1, 0.2 and 0.3 can be represented accurately in binary. The round off errors from 0.1 and 0.2 accumulate and hence there is a difference of 5.5511e-17 between (0.1 + 0.2) and 0.3.

In the code shown above, we have not passed any parameter to the function p. Hence the output of this code is: hello.

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.

The code shown above returns a new list containing only those elements of the list l which do not amount to zero. Hence the output is: [1, 2, ‘hello’].

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.

abcd a a a is the output as x is modified only after ‘abcd’ has been printed once.

This is a built-in function which rounds a number to give precision in decimal digits. In the above case, since the number of decimal places has not been specified, the decimal number is rounded off to a whole number. Hence the output will be 5.