OAU CSC 201 Practice Quiz

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.

Suppose we have an expression ~A. This is evaluated as: -A – 1. Therefore, the expression ~100 is evaluated as -100 – 1, which is equal to -101.

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.

Padding is done towards the right-hand-side first when the final string is of even length.

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 code shown above demonstrates rebinding using a static method. This can be done with or without a decorator. The output of this code will be 100.

For order of precedence, just remember this PEMDAS (similar to BODMAS).

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.

i is not in x[1:].

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

Objects of type set have no attribute values.

The output that is required is 6, that is, row 2, item 3. This position is represented by the statement: A[1][2].

The elements of the tuple are accessed by their indices.

The result of the expression shown above is (6.0, 16.0). This is because the result is automatically rounded off to one decimal place.

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

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

Loops over key, value pairs.

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.

Variable names can be of any length.

In the snippet of code shown above, three values are inserted into the target string. When we insert more than one value, we should group the values on the right in a tuple. The % formatting expression operator expects either a single item or a tuple of one or more items on its right side.

The order of precedence is: **, //, +. The expression 4+2**5//10 is evaluated as 4+32//10, which is equal to 4+3 = 7. Hence the result of the expression shown above is 7.

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

The formatting option print(“%Ns”,X) helps us add ‘N’ number of spaces before a given string ‘X’. Hence the output for the code snippet shown above will be 56 blank spaces before the string “san-foundry”.

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.

The code shown above converts the value 255 into hexadecimal, that is, 0xff. The value ‘FF’ into integer. Hence the output of the code shown is: (‘0xff’, 255, 255).

Control exits the loop when i becomes 7.

[::-1] reverses the list.

The above expression is evaluated as 16%15//16, which is equal to 1//16, which results in 0.

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

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’].

+ operator is concatenation operator.

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

Addition and Subtraction” are at the same precedence level. Similarly, “Multiplication and Division” are at the same precedence level. However, Multiplication and Division operators are at a higher precedence level than Addition and Subtraction operators.

If the truth method is not defined, the object is considered true. Hence the output of the code shown above is true.

i takes values 0, 1, 2 and 3.

^ is the XOR operator. The binary form of 4 is 0100 and that of 12 is 1100. Therefore, 0100^1100 is 1000, which is equal to 8.

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

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 output of bin(10-2) = 0b1000 and that of bin(12^4) is ob1000. Hence the output of the above expression is: 0b10000b1000.

The ^ operator represent bitwise XOR operation. &: bitwise AND, | : bitwise OR and ! represents bitwise NOT.

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

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

0O11 is an octal number.

Numbers starting with a 0 are octal numbers but 9 isn’t allowed in octal numbers.

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

The code shown above shows two functions. In both the cases the right operand is returned. This is because each function is evaluated from left to right. Since the left operand is false, it is assumed that the right operand must be true and hence the right operand is returned in each of the above case.

Error, objects of type float cannot be interpreted as an integer.