OAU CSC 201 Practice Quiz

Although the presence of parenthesis does affect the order of precedence, in the case shown above, it is not making a difference. The result of both of these expressions is 1.333333333. Hence the statement is true.

Control exits the loop when i becomes 7.

i takes values 0, 1, 2 and 3.

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.

Variable names can be of any length.

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.

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

In python, power operator is x**y i.e. 2**3=8.

The first letter of the string is converted to uppercase and the others are converted to lowercase.

Coercion is the implicit (automatic) conversion of operands to a common type. Coercion is automatically performed on mixed-type expressions. The expression 1.7 % 2 is evaluated as 1.7 % 2.0 (that is, automatic conversion of int to float).

The code shown above is used to check whether a particular item is a part of a given set or not. Since ‘a’ is a part of the set z, the output is true. Note that this code would result in an error in the absence of the quotes.

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

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’

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.

l (or L) stands for long.

The code shown above displays the string method to round off a given decimal number to two decimal places. Hence the output of the code is: ‘1.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.

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

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.

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

The given number is -122. Here the total number of digits (including the negative sign) should be 6 according to the expression. In addition to this, there is a negative sign in the given print expression. Hence the output will be −−00122.

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

Tuples are represented with round brackets.

[::-1] reverses the string.

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

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

The output of bin(10-2) = 0b1000 and that of bin(12^4) is ob1000. Hence the output of the above expression is: 0b10000b1000.

Bitwise XOR gives 1 if either of the bits is 1 and 0 when both of the bits are 1.

Lists should be copied by executing [:] operation.

In the code shown above, the value for a is substituted by l[0], that is ‘H’, the value of b is substituted by l[-1], that is ‘O’ and the value for c is substituted by l[1:3]. Here the use of *p is to unpack a tuple items into individual function arguments.

+ operator is concatenation operator.

Error, objects of type int aren’t iterable.

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

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.

The output of f(0, 2) is 0, since o%2 is equal to 0. The output of the f(2, 0) is a Zero Division Error. We can make use of decorators in order to avoid this error.

“i” is not in “abcdef”.

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 code snippet shown above results in an error because the above formatting option works only if ‘X’ is a number. Since in the above case ‘X’ is a string, an error is thrown.

Understanding Arithmetic Operators with Strings:

1. * (Multiplication):
• Strings can be multiplied with integers to create repeated copies of the string.
• Example:

print(“abc” * 3) # Output: abcabcabc

• Allowed with strings.

2. – (Subtraction):
• Subtraction is not defined for strings in Python. You cannot subtract one string from another.
• Example:

print(“abc” – “a”) # This will raise a TypeError.

• Not allowed with strings.

3. + (Addition):
• Strings can be concatenated (joined) using the + operator.
• Example:

print(“abc” + “def”) # Output: abcdef

• Allowed with strings.

4. All of the mentioned:
• Since both * and + are allowed with strings, not all arithmetic operators are disallowed. Only – (subtraction) cannot be used with strings.

Correct Answer:

b) –

Subtraction (-) is the arithmetic operator that cannot be used with strings in Python.

Execute help(math.trunc) to get details.

Python is an interpreted programming language, which supports object-oriented, structured, and functional programming.