1. Python provides four modes to open files. The read-only (r), write-only (w), read-write (rw) and append mode (a). ‘r’ is used to open a file in read-only mode, ‘w’ is used to open a file in write-only mode, ‘rw’ is used to open in reading and write mode, ‘a’ is used to open a file in append mode. If the mode is not specified, by default file opens in read-only mode.

2. Read-only mode (r): Open a file for reading. It is the default mode.

3. Write-only mode (w): Open a file for writing. If the file contains data, data would be lost. Other a new file is created.

4. Read-Write mode (rw): Open a file for reading, write mode. It means updating mode.

5. Append mode (a): Open for writing, append to the end of the file, if the file exists.

‍

Type conversion refers to the conversion of one data type into another.  

int() – converts any data type into integer type

oat() – converts any data type into oat type

ord() – converts characters into integer

hex() – converts integers to hexadecimal

oct() – converts integer to octal

tuple() – This function is used to convert to a tuple.  

set() – This function returns the type after converting to set.  

list() – This function is used to convert any data type to a list type.  

dict() – This function is used to convert a tuple of order (key, value) into a dictionary.  

str() – Used to convert integer into a string.

‍

In Python, you can declare variables simply by assigning a value to them.

# Declaring integer variables
age = 30
height = 175  

# Declaring floating-point variables
pi = 3.14
temperature = 25.5  

# Declaring string variables
name = "John Doe"
city = 'New York'  

# Declaring boolean variables
is_student = True
has_car = False

In this example, we have declared different types of variables. ‘age’ and ‘height’ are integers, ‘pi’ and ‘temperature’ are floating-point numbers, ‘name’ and ‘city’ are strings, and ‘is_student’ and ‘has_car’ are boolean values.

If you want to check the type of a variable, you can use the built-in 'type()' function.
For example:

# Checking the type of a variable
age = 30
print(type(age))
# Output: <class 'int'>

temperature = 25.5
print(type(temperature))
# Output: <class 'float'>  

name = "John Doe"
print(type(name))
# Output: <class 'str'>  

is_student = True
print(type(is_student))
# Output: <class 'bool'>

In Python, you can use a list to create an array-like structure. Python lists are dynamic arrays that can hold elements of different data types. You can initialize a list with elements using square brackets [ ] and separate the elements with commas. To find the size of the Python list (i.e., the number of elements it contains), you can use the len() function.

INPUT

# Initializing a Python list (array)
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi']
temperatures = [25.5, 30.2, 28.7, 23.1]

# Finding the size of the lists using the len() function
numbers_size = len(numbers)
fruits_size = len(fruits)
temperatures_size = len(temperatures)

# Printing the lists and their respective sizes
print("Numbers:", numbers)
print("Size of Numbers:", numbers_size)

print("Fruits:", fruits)
print("Size of Fruits:", fruits_size)

print("Temperatures:", temperatures)
print("Size of Temperatures:", temperatures_size)

OUTPUT

Numbers: [1, 2, 3, 4, 5]
Size of Numbers: 5

Fruits: ['apple', 'banana', 'orange', 'grape', 'kiwi']
Size of Fruits: 5

Temperatures: [25.5, 30.2, 28.7, 23.1]
Size of Temperatures: 4

Memory management in python is managed by Python private heap space. All Python objects and data structures are located in a private heap. The programmer does not have access to this private heap. The python interpreter takes care of this instead.

The allocation of heap space for Python objects is done by Python’s memory manager. The core API gives access to some tools for the programmer to code.

Python also has an inbuilt garbage collector, which recycles all the unused memory and so that it can be made available to the heap space.

‍

Explanation: List comprehension is a concise and elegant way to create lists in Python. It allows you to create a new list by applying an expression to each item in an existing iterable (e.g., a list, tuple, or string). The syntax for list comprehension is ‘[expression for item in iterable if condition]’.

# Using list comprehension to create a new list
numbers = [1, 2, 3, 4, 5]

# Create a new list containing the squares of numbers in the 'numbers' list
squared_numbers = [num ** 2 for num in numbers]
print(squared_numbers)  # Output: [1, 4, 9, 16, 25]

# Using list comprehension with a condition
# Create a new list containing only the even numbers from the 'numbers' list
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers)  # Output: [2, 4]

In this example, we used list comprehension to create a new list ‘squared_numbers’, which contains the squares of the elements in the ‘numbers’ list. We also used a conditional expression in list comprehension to create the ‘even_numbers ‘list, which contains only the even elements from the ‘numbers’ list.

List comprehension provides a more readable and compact way to generate lists, making Python code more expressive and Pythonic. It's a powerful tool that Python developers often use to simplify their code and improve code readability.