Amazon Web Services Quiz: Essential AWS Concepts This quiz tests your understanding of core Amazon Web Services (AWS) concepts. Covering essential services like EC2, S3, Lambda, and VPC, it's perfect for interview preparation or to assess your cloud computing knowledge. Happy Learning.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
Python Interview Questions (Intermediate Level) This is a comprehensive set of most asked intermediate-level Python interview questions, designed to test and reinforce understanding of core Python concepts. It covers data structures, functions, object-oriented programming, and advanced topics, making it a valuable resource for interview preparation or skill assessment. Happy Learning.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
def reverse_string(s):
return s[::-1]
result = reverse_string("hello")
print(result) # Output: olleh
def is_palindrome(s):
return s == s[::-1]
result = is_palindrome("madam")
print(result) # Output: True
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
result = factorial(5)
print(result) # Output: 120
def fibonacci(n):
fib_list = [0, 1]
while fib_list[-1] + fib_list[-2] <= n:
fib_list.append(fib_list[-1] + fib_list[-2])
return fib_list
result = fibonacci(10)
print(result) # Output: [0, 1, 1, 2, 3, 5, 8]
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
result = is_prime(17)
print(result) # Output: True
def remove_duplicates(lst):
return list(set(lst))
result = remove_duplicates([1, 2, 2, 3, 4, 4, 5])
print(result) # Output: [1, 2, 3, 4, 5]
def count_occurrences(lst):
counts = {}
for item in lst:
counts[item] = counts.get(item, 0) + 1
return counts
result = count_occurrences([1, 2, 2, 3, 3, 3])
print(result) # Output: {1: 1, 2: 2, 3: 3}
def find_largest(lst):
if not lst:
return None
return max(lst)
result = find_largest([10, 5, 20, 8])
print(result) # Output: 20
def sort_dicts(lst, key):
return sorted(lst, key=lambda x: x[key])
data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
result = sort_dicts(data, 'age')
print(result)
def intersection(list1, list2):
return list(set(list1) & set(list2))
result = intersection([1, 2, 3, 4], [3, 4, 5, 6])
print(result) # Output: [3, 4]
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop() if self.items else None
def peek(self):
return self.items[-1] if self.items else None
def is_empty(self):
return len(self.items) == 0
s = Stack()
s.push(1)
s.push(2)
print(s.pop()) # Output: 2
class Queue:
def __init__(self):
self.items = []
def enqueue(self, item):
self.items.append(item)
def dequeue(self):
return self.items.pop(0) if self.items else None
def is_empty(self):
return len(self.items) == 0
q = Queue()
q.enqueue(1)
print(q.dequeue())
def merge_dicts(dict1, dict2):
return {**dict1, **dict2}
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
result = merge_dicts(dict1, dict2)
print(result) # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
def get_dict_value(dictionary, key, default=None):
return dictionary.get(key, default)
my_dict = {'name': 'Alice', 'age': 30}
result = get_dict_value(my_dict, 'city', 'Unknown')
print(result) # Output: Unknown
def create_tuples(list1, list2):
return list(zip(list1, list2))
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
result = create_tuples(list1, list2)
print(result) # Output: [(1, 'a'), (2, 'b'), (3, 'c')]
def unzip_tuples(tuple_list):
return list(zip(*tuple_list))
tuple_list = [(1, 'a'), (2, 'b'), (3, 'c')]
result = unzip_tuples(tuple_list)
print(result) # Output: [(1, 2, 3), ('a', 'b', 'c')]
def most_frequent(lst):
counts = {}
for item in lst:
counts[item] = counts.get(item, 0) + 1
return max(counts, key=counts.get)
lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
result = most_frequent(lst)
print(result) # Output: 4
def all_values_same(dictionary):
if not dictionary:
return True
values = list(dictionary.values())
return values.count(values[0]) == len(values)
dict1 = {'a': 1, 'b': 1, 'c': 1}
dict2 = {'a': 1, 'b': 2, 'c': 1}
print(all_values_same(dict1)) # Output: True
print(all_values_same(dict2)) # Output: False
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
Advanced Python Programming Quiz designed to challenge and expand your understanding of sophisticated Python concepts. It delves into topics beyond basic syntax, focusing on areas crucial for building efficient, scalable, and robust Python applications. Advanced Python Programming Python Quiz Python Generators Python Decorators Python Asyncio Python Multiprocessing Python Threading Python Context Managers Python Metaclasses Python GIL Python Type Hinting Happy Learning.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
Python Object-Oriented Programming (OOP) Quiz designed to test your knowledge of fundamental OOP concepts. It presents a series of multiple-choice questions covering topics such as: Classes and Objects: Understanding the basic building blocks of OOP. Instantiation: The process of creating objects from classes. Attributes and Methods: Distinguishing between data and behavior within classes. Inheritance: Creating new classes based on existing ones. Polymorphism: The ability of objects to take on multiple forms. Encapsulation: Hiding data and methods within a class. Abstraction: Simplifying complex systems through modeling. Special Methods: Understanding the purpose of methods like __init__ and __str__. Instance and Class Variables: Knowing the difference between them. isinstance() and super(): Utilizing built-in functions for OOP. The app provides an interactive experience, allowing you to select your answers and receive immediate feedback. Upon submission, it calculates your score and highlights correct and incorrect answers, making it a valuable tool for learning and reinforcing your understanding of Python OOP. Happy Learning.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
A practical guide to troubleshooting Python code. Discover some common mistakes that Python programmers make, along with detailed explanations and solutions to help you debug effectively.
· Missing Colons: Forgetting the colon (:) at the end of if, for, while, and def statements.
· Explanation: Colons are essential syntax in Python to indicate the start of a code block.
· Incorrect Indentation: Python relies heavily on indentation; inconsistent indentation causes errors.
· Mismatched Parentheses/Brackets: Not closing parentheses, brackets, or braces properly.
· Misspelled Keywords: Incorrectly typing keywords like if, else, while, or def.
· Invalid Characters: Using characters that are not allowed in Python syntax.
· Off-by-One Errors: In loops and indexing, forgetting zero-based indexing.
· Incorrect Boolean Logic: Using incorrect logical operators (and, or, not).
· Variable Scope Issues: Trying to access a variable outside its scope.
· Incorrect Loop Conditions: Setting loop conditions that never terminate or terminate prematurely.
· Incorrect Function Logic: Functions not returning expected values or producing incorrect results.
· TypeError: Using an operator or function with incompatible data types.
· NameError: Trying to use a variable that hasn't been defined.
· IndexError: Trying to access an index out of range.
· KeyError: Trying to access a key that doesn't exist in a dictionary.
· ValueError: Using a function with an argument of the correct type but an inappropriate value.
· ZeroDivisionError: Attempting to divide by zero.
· AttributeError: Trying to access an attribute that doesn't exist on an object.
· FileNotFoundError: Trying to open a file that doesn't exist.
· ImportError: Trying to import a module that can't be found.
· MemoryError: Running out of memory.
· Mutable Default Arguments: Using mutable objects as default arguments in functions.
· Not Handling Exceptions: Failing to use try...except blocks to handle potential errors.
· Inefficient Loops: Using nested loops unnecessarily or iterating over large data structures inefficiently.
· Incorrect File Handling: Not closing files or not handling file-related exceptions.
· Incorrect String Formatting: Using incorrect formatting techniques for strings.
· Incorrect Use of Global Variables: Modifying global variables without proper understanding.
· Incorrect Use of Lambda Functions: Using lambda functions in inappropriate contexts or with incorrect syntax.
· Incorrect Use of List Comprehensions: Creating complex list comprehensions that are difficult to understand.
· Incorrect Use of Dictionaries: Using dictionaries with mutable keys or incorrect access methods.
· Incorrect Use of Sets: Using sets with mutable elements or incorrect set operations.
· Incorrect Use of Tuples: Trying to modify tuples after they are created.
· Incorrect Use of Classes: Incorrectly defining classes, methods, or attributes.
· Incorrect Use of Inheritance: Improperly inheriting from parent classes.
Working as a software engineer, started blogging to share the information. My posts usually includes, tips and tricks on daily computer use, and how to series on MS Office.
