How to pass Python Interview test in 2023
Interview Test by CGit
Section 1: Python basics
What is Python? What are some of the advantages of using Python?
Answer: Python is a high-level, interpreted programming language that was first released in 1991. It is widely used in many areas such as data science, artificial intelligence, web development, scientific computing, and more.
Some of the advantages of using Python are:
Easy to Learn: Python has a simple and easy-to-understand syntax that makes it easy to learn and use. This makes it a popular language for beginners.
Cross-Platform Support: Python can be run on various operating systems like Windows, macOS, Linux, and others. This makes it a versatile language for developing applications.
Large Standard Library: Python has a large and comprehensive standard library that provides many useful modules and functions for tasks such as web development, data analysis, scientific computing, and more.
Rich Ecosystem: Python has a vast ecosystem of third-party packages and libraries that can be easily installed using tools like pip. These libraries provide additional functionality for tasks like machine learning, natural language processing, web development, and more.
Dynamically Typed: Python is a dynamically typed language, which means that variable types are determined at runtime, making it more flexible and easier to write code.
Object-Oriented: Python is an object-oriented language, which makes it easier to write and maintain large programs. It allows for the creation of reusable code and has many features for working with objects, classes, and inheritance.
Strong Community: Python has a large and active community of developers who contribute to the language and its ecosystem. This community provides support, resources, and tools for learning and using Python.
Explain the difference between a list and a tuple in Python.
Answer: In Python, both lists and tuples are used to store a collection of elements, but they have some differences in their characteristics and use cases.
A list is a mutable collection of ordered elements enclosed in square brackets []. This means that once a list is created, its elements can be modified by adding, removing, or changing values. Lists are commonly used when we need to store data that can be changed or updated, such as user input or dynamic data. Here’s an example of a list:
Python code:
| my_list = [ | ‘apple’ | , | ‘banana’ | , | ‘orange’ | , | ‘grape’ | ] |
On the other hand, a tuple is an immutable collection of ordered elements enclosed in parentheses (). This means that once a tuple is created, its elements cannot be modified. Tuples are commonly used when we need to store data that should not be changed, such as constant values or data that should not be accidentally modified. Here’s an example of a tuple:
Python code:
| my_tuple = ( | ‘red’ | , | ‘green’ | , | ‘Blue’ | ) |
Here are some key differences between lists and tuples:
Mutability: Lists are mutable, and tuples are immutable.
Syntax: Lists are enclosed in square brackets [], while tuples are enclosed in parentheses ().
Performance: Tuples are faster than lists when it comes to accessing elements, as they are implemented as a contiguous block of memory. Lists, on the other hand, are implemented as an array of pointers to objects, which makes them slower to access.
Use case: Use lists when you need to store a collection of data that can be changed or updated and use tuples when you need to store a collection of data that should not be changed or updated.
What is the difference between a set and a dictionary in Python?
Answer: In Python, both sets and dictionaries are used to store a collection of elements, but they have some differences in their characteristics and use cases.
A set is an unordered collection of unique elements, enclosed in curly braces {}. This means that sets do not allow duplicate elements, and the order of elements is not preserved. Sets are commonly used when we need to store a collection of unique elements or when we need to perform set operations such as union, intersection, or difference. Here’s an example of a set:
Python code:
| my_set = { | 1 | , | 2 | , | 3 | , | 4 | } |
On the other hand, a dictionary is an unordered collection of key-value pairs, enclosed in curly braces {}. This means that each element in a dictionary consists of a key and a corresponding value, and the order of elements is not preserved. Dictionaries are commonly used when we need to store a collection of data that can be accessed using a unique key, such as a database or a configuration file. Here’s an example of a dictionary:
Python code:
| my_dict = { | ‘apple’ | : | 1 | , | ‘banana’ | : | 2 | , | ‘orange’ | : | 3 | , | ‘grape’ | : | 4 | } |
Here are some key differences between sets and dictionaries:
Element type: Sets store a collection of unique elements, while dictionaries store key-value pairs.
Access method: Sets are accessed using the “in” operator to check if an element is present in the set, while dictionaries are accessed using keys to get the corresponding value.
Use case: Use sets when you need to store a collection of unique elements or perform set operations, and use dictionaries when you need to store a collection of data that can be accessed using a unique key.
How do you create a function in Python? What is the syntax for defining a function?
Answer: In Python, you can create a function using the def keyword followed by the function name, parameter(s), and a colon (:). Here’s the syntax for defining a function:
python code:
| def | function_name | ( | parameter1, parameter2, … | ): | # function body | # statements to be executed when the | ||||||
| function is called | return | value | ||||||||||
Let’s break down the syntax:
def: This is the keyword used to define a function.
function name: This is the name of the function. Choose the function that describes what the function does.
(parameter1, parameter2, …): These are the parameters (inputs) that the function takes. You can specify zero or more parameters separated by commas.
:: This is a colon that marks the end of the function header and the beginning of the function body.
# Function body: This is where you write the statements that will be executed when the function is called.
return value: This statement specifies the value that the function will return to the caller. If the function does not return any value, you can omit this statement.
Here’s an example of a function that takes two parameters and returns their sum:
Python code:
| def | add_numbers | ( | x, y | ): result = x + y | return | result |
You can call this function by passing two arguments:
python code:
| sum | = add_numbers( | 2 | , | 3 | ) | ( | sum | ) | # Output: 5 |
This will call the add_numbers function with the arguments 2 and 3, and assign the result to the variable sum. The function will return the value 5, which will be printed to the console
What is a lambda function in Python? How is it different from a regular function?
Answer: In Python, a lambda function is a small, anonymous function that can have any number of parameters, but can only have one expression. Lambda functions are created using the lambda keyword, which is followed by the function parameters and a colon (:), and then the expression to be evaluated. Here’s the syntax for defining a lambda function:
python code:
| lambda | arguments: expression |
Here’s an example of a lambda function that takes two arguments and returns their sum:
python code:
| sum | = | lambda | x, y: x + y |
You can call this lambda function just like a regular function:
Python code:
| result = | sum | ( | 2 | , | 3 | ) | (result) | # Output: 5 |
Lambda functions are different from regular functions in several ways:
Syntax: The syntax for defining a lambda function is more concise than the syntax for defining a regular function. Lambda functions are typically used for small, one-off functions that don’t need to be named.
Name: Lambda functions are anonymous, which means they don’t have a name like regular functions do. Instead, they are typically assigned to a variable or passed as an argument to another function.
Scope: Lambda functions have their scope, which means that any variables created inside a lambda function are local to that function and are not visible outside of it.
Functionality: Lambda functions are typically used for simple operations that can be expressed in a single expression. They are not intended to replace regular functions for more complex operations.
Overall, lambda functions are a handy tool for creating small, simple functions that don’t need to be named or reused, and that can be defined on the fly.
What is the difference between range and range in Python 2. x? Is there a range function in Python3.x?
In Python 2. x, range, and range are both used to generate a sequence of numbers, but they work differently.
The range function returns a list containing an arithmetic progression of integers, starting from a specified start value and stopping before a specified end value. For example, range(1, 5) will return [1, 2, 3, 4]. The range function creates the entire list in memory, which can be inefficient if the list is very large.
On the other hand, the range function returns a generator object that generates the numbers in the sequence on-the-fly, as they are needed. This means that xrange is more memory efficient than range when dealing with large sequences of numbers.
In Python 3. x, the xrange function has been removed, and the range has been changed to work like the xrange used to work in Python 2. x. This means that in Python 3. x, the range function returns a generator object that generates the numbers on-the-fly, just like ranged in Python 2. x. If you need to get a list of numbers, you can use the list function to convert the generator object to a list.
Here’s an example of using a range in Python 3. x:
python code:
numbers = range ( 1 , 5 ) print (numbers) # Output: range(1, 5) numbers_list = list (numbers)
print (numbers_list) # Output: [1, 2, 3, 4]
In this example, we use the range function to generate a sequence of numbers from 1 to 4. We then convert the range object to a list using the list function, so that we can print the list of numbers.
Section 2: Object-oriented Programming in Python
What is object-oriented programming? How is it implemented in Python?
Answer: Object-oriented programming (OOP) is a programming paradigm that focuses on the use of objects and their interactions to design applications. In OOP, an object is an instance of a class that encapsulates data and behavior. A class is a blueprint or template for creating objects that define the attributes and methods of the object.
In Python, OOP is implemented through the use of classes and objects. You can create a class in Python using the class keyword, followed by the name of the class and a colon.
Here’s an example of a simple class in Python:
Python code:
| class | Person | : | def | __init__ | ( | self, name, age | ): self.name = name self.age = age | def | say_hello | ( | self | ): | |||||||
| ( | f”Hello, my name is {self.name} and I am {self.age} years old.” | ) | |||||||||||||||||
In this example, we define a class called Person that has two attributes (name and age) and one method (say_hello). The __init__ method is a special method that is called when a new object of the class is created. It initializes the object with the values passed as arguments to the constructor. The say_hello method is a simple method that prints out a message with the person’s name and age.
To create an object of this class, we can use the following syntax:
Python code:
| person1 = Person( | “John” | , | 25 | ) |
This creates a new object of the Person class with the name “John” and age 25. We can then call the say_hello method on this object:
Python code:
| person1.say_hello() | # Output: Hello, my name is John and I am 25 years old. |
In Python, classes can inherit attributes and methods from other classes using inheritance. This allows you to create more complex class hierarchies and reuse code. Inheritance is implemented by passing the parent class as an argument to the child class definition. Here’s an example:
Python code:
| class | Student | ( | Person | ): | def | __init__ | ( | self, name, age, student_id | ): | super | ().__init__(name, age) |
self.student_id = student_id def say_hello ( self ): print ( f”Hello, my name is {self.name}, I am {self.age}
years old, and my student ID is {self.student_id}.” )
In this example, we define a new class called Student that inherits from the Person class. The __init__ method of the Student class calls the __init__ method of the Person class using the super() function and then initializes the student_id attribute. We also override the say_hello method to include the student ID in the message.
Overall, OOP is a powerful paradigm that allows you to create complex applications by encapsulating data and behavior in objects. Python provides a clean and intuitive syntax for implementing OOP concepts, including classes, objects, inheritance, and polymorphism.
What is the difference between a class and an object in Python?
Answer: In Python, a class is a blueprint or template for creating objects, while an object is an instance of a class.
A class defines the attributes and methods that all objects of that class will have. It is a user-defined data type that encapsulates data and behavior. You can create a class in Python using the class keyword, followed by the name of the class and a colon. Here’s an example of a simple class in Python:
Python code:
| class | Person | : | def | __init__ | ( | self, name, age | ): self.name = name self.age = age | def | say_hello | ( | self | ): | |||||||
| ( | f”Hello, my name is {self.name} and I am {self.age} years old.” | ) | |||||||||||||||||
In this example, a Person is a class that has two attributes (name and age) and one method (say_hello).
On the other hand, an object is an instance of a class. It is created from the blueprint defined by the class and has its own set of attributes and methods. To create an object of a class in Python, you can use the class name followed by parentheses, like this:
Python code:
| person1 = Person( | “John” | , | 25 | ) |
This creates an object of the Person class with the name “John” and age 25. person1 is now an instance of the Person class, with its own set of attributes and methods.
In summary, a class is a blueprint or template for creating objects, while an object is an instance of a class that has its own set of attributes and methods. Classes define the structure and behavior of objects, while objects are the actual instances that contain data and perform operations.
What is inheritance in Python? How does it work?
Answer: Inheritance is a fundamental concept in object-oriented programming that allows you to define a new class based on an existing class. The new class, known as the derived class or subclass, inherits attributes and methods from the existing class, known as the base class or superclass.
In Python, you can create a subclass by defining a new class and specifying the base class in parentheses after the class name. Here’s an example:
Python Code:
class Animal : def __init__ ( self, name ): self.name = name def speak ( self ): raise
NotImplementedError( “Subclass must implement abstract method” ) class Dog ( Animal ): def
| speak | ( | self | ): | return | “Woof” | class | Cat | ( | Animal | ): | def | speak | ( | self | ): | return | “Meow” |
In this example, we define a base class called Animal with an __init__ method that initializes the name attribute and a speak method that raises a NotImplementedError. We then define two subclasses, Dog and Cat, that inherit from the Animal class. Each subclass overrides the speak method to provide its implementation.
When you create an object of a subclass, it inherits all the attributes and methods of the base class, including any overridden methods. Here’s an example of how to use these classes:
Python code:
| dog = Dog( | “Rufus” | ) cat = Cat( | “Whiskers” | ) | (dog. name) | # Output: Rufus | (dog.speak()) | # Output: | ||||||||||||
| Woof | (cat. name) | # Output: Whiskers | (cat.speak()) | # Output: Meow | ||||||||||||||||
In this example, we create an object of the Dog class called Dog with the name “Rufus” and an object of the Cat class called Cat with the name “Whiskers”. We then print out the name attribute of each object and call the speak method.
Overall, inheritance is a powerful mechanism in Python that allows you to reuse code and define more complex class hierarchies. By inheriting from a base class, you can extend and customize its behavior while retaining its fundamental structure.
Explain the difference between a class method and an instance method in Pyt.on?
Answer: In Python, a class method is a method that is bound to the class and not the instance of the class. It is defined using the @classmethod decorator and takes the class as its first argument (usually named cls) instead of the instance.
An instance method, on the other hand, is a method that is bound to the instance of the class. It is defined using the self parameter, which refers to the instance of the class.
Here’s an example that demonstrates the difference between class methods and instance methods:
Python code:
class MyClass : class_variable = 0 def __init__ ( self, instance_variable ): self.instance_variable =
instance_variable def instance_method ( self ): print ( “This is an instance method” ) print ( “Instance
variable:”, self.instance_variable) print ( “Class variable:”, MyClass.class_variable) @classmethod def class_method ( cls ): print ( “This is a class method” ) print ( “Class variable:”, cls.class_variable) my_object
| = MyClass( | “Hello” | ) my_object.instance_method() MyClass.class_method() |
In this example, we define a class called MyClass with an instance variable called instance_variable and a class variable called class_variable. We also define two methods: instance_method and class_method.
When we create an object of MyClass called my_object, we can call the instance_method method on it. This method takes the self as its first parameter, which refers to the instance of the class. We can access the instance variable and class variable using the self and MyClass references, respectively.
We can also call the class_method method on the MyClass class itself. This method takes cls as its first parameter, which refers to the class. We can access the class variable using the class reference.
Overall, class methods and instance methods serve different purposes in Python. Class methods are used when you need to access or modify the class-level attributes, while instance methods are used when you need to work with the instance-level attributes.
What is the init method in Python? How is it used?
Answer: In Python, the __init__ method is a special method that is called when an object is created from a class. It is also known as the constructor method because it is used to initialize the attributes of the object.
The __init__ method takes the self parameter as its first argument, which refers to the instance of the class being created. It can also take additional parameters that are used to initialize the attributes of the object.
Here’s an example of how to use the __init__ method:
Python code:
class Person : def __init__ ( self, name, age ): self.name = name self.age = age def greet ( self ):
print ( “Hello, my name is”, self. name, “and I am”, self. age, “years old.” ) person1 = Person( “Alice”, 30 )
| person1.greet() person2 = Person( | “Bob” | , | 25 | ) person2.greet() |
In this example, we define a Person class with an __init__ method that initializes the name and age attributes of the object. We also define a greeting method that prints out a greeting message using the name and age attributes.
When we create a new Person object, we pass in the name and age arguments to the __init__ method. This initializes the name and age attributes of the object with the values we provided.
We can then call the greet method on each object to print out a greeting message that uses the name and age attributes.
Overall, the __init__ method is a powerful tool in Python that allows you to initialize the attributes of an object when it is created. It is an important part of the object-oriented programming paradigm and is widely used in Python programming.
What is the difference between private, protected, and public access modifiers in Python?
Answer: In Python, there is no real concept of access modifiers like in some other programming languages such as Java. However, some conventions are used to indicate the intended visibility of a class attribute or method.
By convention, an attribute or method that is intended to be private is prefixed with a double underscore (__). This makes the attribute or method “name-mangled”, meaning that it is renamed with a prefix that includes the class name. This makes it difficult to access the attribute or method from outside the class.
An attribute or method that is intended to be protected is prefixed with a single underscore (_). This indicates that the attribute or method should not be accessed or modified from outside the class, but it is not name-mangled like a private attribute or method.
An attribute or method that is intended to be public does not have any prefix. It can be accessed and modified from outside the class without any restrictions.
Here’s an example that demonstrates the use of private, protected, and public attributes in Python:
Python code:
| class | MyClass | : | def | __init__ | ( | self | ): self.public_attribute = | “This is a public attribute” |
self._protected_attribute = “This is a protected attribute” self.__private_attribute = “This is a private
attribute” def public_method ( self ): print ( “This is a public method” ) self.__private_method() def _protected_method ( self ): print ( “This is a protected method” ) def __private_method ( self ): print ( “This is a private method” ) my_object = MyClass() print (my_object.public_attribute)
| (my_object._protected_attribute) | (my_object._MyClass__private_attribute) |
my_object.public_method() my_object._protected_method() my_object._MyClass__private_method()
In this example, we define a MyClass class with a public attribute called public_attribute, a protected attribute called _protected_attribute, and a private attribute called __private_attribute.
We also define a public method called public_method, a protected method called _protected_method, and a private method called __private_method.
When we create an object of MyClass called my_object, we can access the public attribute and call the public method without any restrictions.
We can also access the protected attribute and call the protected method, but by convention, we should not do this from outside the class. We can access the private attribute and call the private method using the name-mangled version of the attribute and method names, but again, by convention, we should not do this from outside the class.
Overall, while Python does not have strict access modifiers like other programming languages, the conventions of using single and double underscores to indicate the intended visibility of class attributes and methods are widely used and understood by Python programmers.
Section 3: Python programming scenarios
- Write a Python program that reads a list of numbers from the user and prints the sum of the even numbers.
Answer: Here’s a Python program that reads a list of numbers from the user and prints the sum of the even numbers: pythonCopy code
| # read a list of numbers from the user | num_list = | input | ( | “Enter a list of numbers separated by spaces: |
| “ | ).split() | # initialize the sum to 0 | even_sum = | 0 | # Loop through each number in the list | for | num | in |
num_list: # check if the number is even if int (num) % 2 == 0: # add the even number to the sum even_sum += int (num) # print the sum of the even numbers print ( “The sum of the even numbers is:” even_sum)
In this program, we first read a list of numbers from the user using the input function. We split the input string into a list of individual numbers using the split method.
We then initialize a variable even_sum to 0 to keep track of the sum of the even numbers.
Next, we loop through each number in the list using a for loop. For each number, we check if it is even by taking the remainder of the number divided by 2 using the modulo operator %. If the remainder is 0, then the number is even, so we add it to the even_sum variable.
Finally, we print the sum of the even numbers using the print function.
- Write a Python program that reads a string from the user and prints the number of vowels in the string.
Answer: Here’s a Python program that reads a string from the user and prints the number of vowels in the string:
Python code:
| # read a string from the user | string = | input | ( | “Enter a string: “ | ) | # define a list of vowels | vowels = [ | ‘a’ | , | ‘e’ | , | ‘i’ | , | ||||||||||||||||||||||
| ‘o’ | , | ‘u’ | ] | # initialize a count variable to 0 | count = | 0 | # Loop through each character in the string | for | char | in | |||||||||||||||||||||||||
| string: | # check if the character is a vowel | if | char.lower() | in | vowels: | # increment the count variable | count | ||||||||||||||||||||||||||||
| += | 1 | # print the number of vowels in the string | ( | “The number of vowels in the string is:” | , count) | ||||||||||||||||||||||||||||||
In this program, we first read a string from the user using the input function.
We then define a list of vowels [‘a’, ‘e’, ‘i’, ‘o’, ‘u’].
Next, we initialize a variable count to 0 to keep track of the number of vowels in the string.
We loop through each character in the string using a for loop. For each character, we check if it is a vowel by checking if it is in the vowels list (we convert the character to lowercase first using the lower method). If the character is a vowel, we increment the count variable.
