OAU CSC 201 Practice Quiz

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.

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 code shown above shows a general decorator which can work with any number of arguments.

The formatting method {1:<10} represents the second positional argument, left justified in a 10 character wide field.

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

[::-1] reverses the string.

getopt parses options received from the command line.

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

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

Execute help(id) to find out details in python shell.id returns a integer value that is unique.Execute help(id) to find out details in python shell.id returns a integer value that is unique.

Variable names can be of any length.

math.pow() returns a floating point number.

cmp(x, y) returns 1 if x > y, 0 if x == y and -1 if x < y.

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.

pip is a package manager for python. Which is also called Preferred Installer Program.

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

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

The expression shown above is evaluated as: 2+9*(36-8)/10, which simplifies to give 2+9*(2.8), which is equal to 2+25.2 = 27.2. Hence the result of this expression is 27.2.

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.

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.

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

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.

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

Python language is designed by a Dutch programmer Guido van Rossum in the Netherlands.

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

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

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

he function sys.version can help us to find the version of python that we are currently working on. It also contains information on the build number and compiler used. For example, 3.5.2, 2.7.3 etc. this function also returns the current date, time, bits etc along with the version.

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.

0O11 is an octal number.

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

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

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

+ will append the element to the list.

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

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

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

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

range(str) is not allowed.

Within the subject string, curly braces designate substitution targets and arguments to be inserted either by position or keyword. Hence the output of the code shown above:’hello, good,and morning’.

The code shown above shows the formatting option on the same value, that is 4.56, where in the second case, the value is enclosed in a list. Hence the output of the code shown above is:
‘4.56’, ‘[4.56]’

The function len() returns the length of the number of elements in the iterable. Therefore the output of the function shown above is 4.

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’

Execute in the shell.