1

Resposta de referência

- The list data structure of python is very highly efficient and is capable of performing various functions. But, they have severe limitations when it comes to the computation of vectorized operations which deals with element-wise multiplication and addition. The python lists also require the information regarding the type of every element which results in overhead as type dispatching code gets executes every time any operation is performed on any element. This is where the NumPy arrays come into the picture as all the limitations of python lists are handled in NumPy arrays. - Additionally, as the size of the NumPy arrays increases, NumPy becomes around 30x times faster than the Python List. This is because the Numpy arrays are densely packed in the memory due to their homogenous nature. This ensures the memory free up is also faster.

2

Resposta de referência

Answer: a) they are used to indicate a private variable of a class As Python has no concept of private variables, leading underscores are used to indicate variables that must not be accessed from outside the class.

3

Resposta de referência

# Creating a dictionary student = { "name": "John Wick", "age": 28, "major": "Martial Arts and Self Defence.", "university": "Shaolin University" } # Accessing dictionary values print("Name:", student["name"]) print("Age:", student["age"]) print("Major:", student["major"]) print("University:", student["university"])

4

Resposta de referência

Mutable built-in types: List, Sets, and Dictionaries. Immutable built-in types: String, Tuples, and numbers

5

Resposta de referência

The Python long function will convert a string to a long. The second parameter is for the base of the number, so 10 for decimal numbers. x = '100' long(x, 10)

6

Resposta de referência

def merge_sort(arr): # Merge Sort Function if len(arr) > 1: mid = len(arr) // 2 left_part = arr[:mid] right_part = arr[mid:] merge_sort(left_part) merge_sort(right_part) i = j = k = 0 while i < len(left_part) and j < len(right_part): if left_part[i] < right_part[j]: arr[k] = left_part[i] i += 1 else: arr[k] = right_part[j] j += 1 k += 1 while i < len(left_part): arr[k] = left_part[i] i += 1 k += 1 while j < len(right_part): arr[k] = right_part[j] j += 1 k += 1 numbers = input("Enter the List of numbers= ").split() numbers = [int(num) for num in numbers] merge_sort(numbers) print("Sorted list =", numbers)

7

Resposta de referência

- You can use split() function to split a string based on a delimiter to a list of strings. - You can use join() function to join a list of strings based on a delimiter to give a single string. string = "This is a string." string_list = string.split(' ') #delimiter is 'space' character or ' ' print(string_list) #output: ['This', 'is', 'a', 'string.'] print(' '.join(string_list)) #output: This is a string.

8

Resposta de referência

Lambda functions, also known as anonymous functions, are small, one-line functions without a name. They are defined using the lambda keyword and can take any number of arguments but can only have one expression. They are often used for short, throwaway functions.

9

Resposta de referência

- List: Ordered, mutable collection of elements. - Tuple: Ordered, immutable collection. - Set: Unordered, unique elements. - Dictionary: Key-value pairs. Example: my_list = [1, 2, 3] my_tuple = (1, 2, 3) my_set = {1, 2, 3} my_dict = {"key1": "value1", "key2": "value2"}

10

Resposta de referência

def bubble_sort(arr): # Bubble Sort Function n = len(arr) for i in range(n - 1): for j in range(n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] numbers = input("Enter the List of numbers: ").split() numbers = [int(num) for num in numbers] bubble_sort(numbers) # Calling bubble sort function print("Sorted list:", numbers) # Sorted List

11

Resposta de referência

- Mutable: Can be changed (e.g., lists, dictionaries). - Immutable: Cannot be changed (e.g., strings, tuples)

12

Resposta de referência

my_list = [50, "Twenty", 110, "Fifty", "Ten", 20, 10, 80, "Eighty"] my_tuple = (my_list[0], my_list[len(my_list) - 1], len(my_list)) print(my_tuple) Output: (50, 'Eighty', 9) All we have to do is create a tuple with three elements. The first element of the tuple is the first element of the list, which can be found using my_list[0] . The second element of the tuple is the last element in the list. my_list[len(my_list) - 1] will give us this element. We could also have used the pop() method, but that would alter the list.

13

Resposta de referência

List comprehension is a way to create lists using a concise syntax. It allows us to generate a new list by applying an expression to each item in an existing iterable (such as a list or range). This helps us to write cleaner, more readable code compared to traditional looping techniques. For example, if we have a list of integers and want to create a new list containing the square of each element, we can easily achieve this using list comprehension. a = [2,3,4,5] res = [val ** 2 for val in a] print(res) Output [4, 9, 16, 25]

14

Resposta de referência

This is how we can use write a view in Django: from django.http import HttpResponse import datetime def Current_datetime(request): now = datetime.datetime.now() html = "It is now %s/body/html % now return HttpResponse(html) Returns the current date and time, as an HTML document

15

Resposta de referência

The == operator checks for equality of values, while the is operator checks for identity, meaning it checks if two variables refer to the same object in memory. a = [1, 2, 3] b = [1, 2, 3] print(a == b) # True (values are equal) print(a is b) # False (different objects in memory)

16

Resposta de referência

You can create a boolean matrix by creating a two-dimensional array where each element is a boolean value. For example, Creating a 3x3 boolean matrix filled with False values Loading... Setting some values to True Loading... Printing the matrix Loading...

17

Resposta de referência

Docstrings are string literals used to document functions, classes, and modules. They are used to provide information about the purpose and usage of code, making it more understandable and maintainable.

18

Resposta de referência

The pass statement in Python is a null operation that does nothing when executed. It is used as a placeholder in code blocks where a statement is syntactically required but no action is desired, such as in empty functions or loops.

19

Resposta de referência

The functionality of the TensorFlow library revolves around enabling machine learning and deep learning computations. TensorFlow, developed by Google, is an open-source framework primarily designed for numerical computations using data flow graphs. Nodes represent operations, while edges represent the data (tensors) that flow between these graphs. This graphical representation allows TensorFlow to be highly scalable and deployable across various platforms, from desktops to clusters of servers. TensorFlow supports a range of tasks. It is versatile, serving both beginners with high-level APIs and researchers with more granular control over model architectures. You can build, train, and deploy machine learning models efficiently, whether they are simple linear regressions or complex neural networks with TensorFlow. TensorFlow extends its capabilities to TensorFlow Lite for mobile and edge devices and TensorFlow.js for browser-based applications.

20

Resposta de referência

Python is a high-level, interpreted programming language known for its readability and simplicity. Key features include dynamic typing, an extensive standard library, cross-platform compatibility, and support for multiple programming paradigms such as object-oriented, procedural, and functional programming. Its advantages include rapid development, strong community support, and versatility across domains like web development, data science, and automation.

21

Resposta de referência

Python modules are files containing Python code, such as functions, classes, and variables, that can be imported and used in other Python programs. They help organize code and promote reusability.

22

Resposta de referência

The __init__() method is a special method (constructor) in Python classes. It is called automatically when an object is created from the class and is used to initialize the object's attributes. It allows you to set the initial state of the object.

23

Resposta de referência

First sort intervals by start time, then go through them and merge if the current interval overlaps with the last one in result, otherwise just add it, this makes the solution clean and fast. def merge(intervals): intervals.sort() res = [intervals[0]] for s, e in intervals[1:]: last_s, last_e = res[-1] if s <= last_e: res[-1][1] = max(last_e, e) else: res.append([s, e]) return res print(merge([[1,3],[2,6],[8,10],[15,18]]))

24

Resposta de referência

def is_balanced_parentheses(string): stack = Stack() for char in string: if char == '(': stack.push(char) elif char == ')': if stack.is_empty(): return False stack.pop() return stack.is_empty() Explanation of solution: This function iterates through each character in the input string. If an opening parenthesis is encountered, it is pushed onto the stack. For a closing parenthesis, the function checks if the stack is empty (unmatched closing parenthesis) or pops from the stack (matching pair found). At the end, if the stack is empty, all parentheses are balanced; otherwise, they are not.

25

Resposta de referência

Will make use of dropna() to remove the values that are missing or fillna() to fill them in. Example: df = df.fillna(0) # Replace missing values with 0

26

Resposta de referência

Normalization scales data to a specific range, usually [0, 1], while standardization transforms it to have a mean of 0 and a standard deviation of 1. Both techniques are essential for preparing data for machine learning models. from sklearn.preprocessing import MinMaxScaler, StandardScaler import numpy as np data = np.array([[1, 2], [3, 4], [5, 6]]) # Normalize normalizer = MinMaxScaler() normalized = normalizer.fit_transform(data) print(normalized) # Standardize scaler = StandardScaler() standardized = scaler.fit_transform(data) print(standardized)

27

Resposta de referência

To convert a string to lowercase, lower() function can be used. Example: stg='ABCD' print(stg.lower()) Output: abcd

28

Resposta de referência

In the case of compiled languages, the source code is translated entirely into machine code by a compiler before execution. The resulting compiled program can be directly executed by the computer's processor, providing fast and efficient performance. Ex – C, C++, and Rust. And in the case of Interpreted language, an interpreter reads and executes the source code line by line at runtime. The interpreter translates each line of code into machine code while the program is running. Ex- Python, JavaScript, and Ruby.

29

Resposta de referência

There are many Python web scrapping libraries - The Farm: Requests The St ew: Beautiful Soup 4 The Salad: lxml - The Restaurant: Selenium The Chef: Scrapy

30

Resposta de referência

Global Variables: Variables declared outside a function or in global space are called global variables. These variables can be accessed by any function in the program. Local Variables: Any variable declared inside a function is known as a local variable. This variable is present in the local space and not in the global space.

31

Resposta de referência

The pickle module is used for serializing and deserializing Python objects, allowing you to save and load data structures.

32

Resposta de referência

- Answer: Discuss identifying essential elements (username, password field, login button), using explicit waits to handle page loads, and capturing successful login confirmation. - Example Code: from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC driver = webdriver.Chrome() driver.get('https://example.com/login') wait = WebDriverWait(driver, 10) username = wait.until(EC.presence_of_element_located((By.ID, 'username'))) username.send_keys('myuser') password = driver.find_element(By.ID, 'password') password.send_keys('mypassword') login_button = driver.find_element(By.ID, 'login') login_button.click() wait.until(EC.url_contains('dashboard')) print('Login successful')

33

Resposta de referência

- Sorting: Use sorted() or .sort(). - Searching: Use the in operator or methods like .index(). Example: nums = [5, 2, 9] # Sorting the list nums.sort() print(nums) # [2, 5, 9] # Checking if 9 is in the list print(9 in nums) # True

34

Resposta de referência

Explanation: pd.merge() combines df1 and df2 on the id column. The how parameter specifies the type of join: inner, outer, left, or right. Code: import pandas as pd # Sample data data1 = {'id': [1, 2, 3, 4], 'name': ['Alice', 'Bob', 'Charlie', 'David']} data2 = {'id': [3, 4, 5, 6], 'age': [25, 30, 35, 40]} # Creating DataFrames df1 = pd.DataFrame(data1) df2 = pd.DataFrame(data2) # Merging on the 'id' column merged_df = pd.merge(df1, df2, on='id', how='inner') # Use 'outer', 'left', or 'right' for different join types # Display the merged DataFrame print(merged_df)

35

Resposta de referência

You can select a single column by using square brackets and the column name as a string``. For example: `df[````'column_name']`.

36

Resposta de referência

Creating a module in Python is fairly simple. - First, open a text editor and create a new file. - Add the code you want to include in the module. You can include various functions and classes, as well as global variables. - Save the file with a .py extension (e.g. myModule.py). - Import the module using the import statement. - Use the module's functions and classes in your program.

37

Resposta de referência

Writing efficient Python code significantly impacts the performance and scalability of your application. Strategies include: - Utilize Built-in Functions and Libraries: Python's standard library is rich with built-in functions that are highly optimized and faster than manually crafted solutions. For instance, using map() or filter() for data processing can be more efficient than equivalent for-loops. - Leverage List Comprehensions and Generator Expressions: These features make your code more concise and efficient. List comprehensions can replace bulky for-loops, and generator expressions allow for lazy evaluation, saving memory when dealing with large datasets. - Profile Before Optimizing: Use profiling tools like cProfile to identify bottlenecks. Optimization efforts should be data-driven. - Minimize Memory Footprint: Use __slots__ to reduce the memory footprint of objects, and consider using arrays from the array module instead of lists for large sequences of numerical data. - Take Advantage of Local Variables: Accessing local variables is faster than accessing global variables. Encapsulating code in functions can lead to performance gains. - Avoid Premature Optimization: Focus on writing clear and maintainable code first, then optimize once you've identified performance issues. - Use Third-Party Libraries When Appropriate: Libraries such as NumPy and Pandas are optimized for performance and can handle data operations more efficiently than pure Python code. - Understand the Global Interpreter Lock (GIL): The GIL can be a bottleneck in multi-threaded Python programs. Consider using multi-processing or alternative Python implementations like Jython or IronPython for CPU-bound tasks.

38

Resposta de referência

A deep copy refers to cloning an object. When we use the = operator, we are not cloning the object; instead, we reference our variable to the same object (a.k.a. shallow copy). This means that changing one variable's value affects the other variable's value because they are referring (or pointing) to the same object. This difference between a shallow and a deep copy is only applicable to objects that contain other objects, like lists and instances of a class. Method To make a deep copy (or clone) of an object, we import the built-in copy module in Python. This module has the deepcopy() method which simplifies our task. Syntax This function takes the object we want to clone as its only argument and returns the clone. import copy # Using '=' operator x = [1, 2, 3] y = x x[0] = 5 # value of 'y' also changes as it is the SAME object x[1] = 15 print "Shallow copy: ", y # Using copy.deepcopy() a = [10, 20, 30] b = copy.deepcopy(a) a[1] = 70 # value of 'b' does NOT change because it is ANOTHER object print "Deep copy: ", b Output: Shallow copy: [5, 15, 3] Deep copy: [10, 20, 30]

39

Resposta de referência

A module is a single file that contains Python code (functions, variables, classes) which can be reused in other programs. You can think of it as a code library. For example: math is a built-in module that provides math functions like sqrt(), pi, etc. import math print(math.sqrt(16)) Output 4.0 Package is a collection of related modules stored in a directory. It helps in organizing and grouping modules together for easier management. For example: The numpy package contains multiple modules for numerical operations. To create a package, the directory must contain a special file named __init__.py.

40

Resposta de referência

41

Resposta de referência

Using filter: filter(lambda x: x % 2 == 0, [1, 2, 3, 4]) returns [2, 4]. Using reduce: from functools import reduce; reduce(lambda x, y: x * y, [1, 2, 3, 4]) returns 24.

42

Resposta de referência

The built-in datatypes in Python is called dictionary. It defines one-to-one relationship between keys and values. Dictionaries contain pair of keys and their corresponding values. Dictionaries are indexed by keys. Let's take an example: The following example contains some keys. Country, Capital & PM. Their corresponding values are India, Delhi and Modi respectively. dict={'Country':'India','Capital':'Delhi','PM':'Modi'} print dict[Country] Output:India print dict[Capital] Output:Delhi print dict[PM] Output:Modi

43

Resposta de referência

Lambda functions are small, anonymous functions defined using the lambda keyword. They can have any number of arguments but only one expression.

44

Resposta de referência

Sample Answer: Permutations refer to all possible arrangements of the elements in a list, where the order of the elements matters. You can leverage Python's built-in 'itertools.permutations()' function to generate these permutations. Here's how you can write a Python function to generate all permutations of a given list: from itertools import permutations def generate_permutations(lst): return list(permutations(lst))

45

Resposta de referência

Indentation helps separate blocks of code by putting four spaces " " between them. While other languages mainly use it to improve code readability, in Python, indentation is a key concept. Indentation helps developers specify a block of code within a loop, a class, or a function. If a programmer tries to run a module without respecting indentation rules, the system will return a failure statement.

46

Resposta de referência

import tensorflow as tf # Creating a constant and a variable tensor const_tensor = tf.constant([1, 2, 3]) var_tensor = tf.Variable([4, 5, 6]) # Performing addition result = const_tensor + var_tensor print(result.numpy()) Explanation of solution: A TensorFlow constant (tf.constant) and variable (tf.Variable) are created. These tensors are then added together using the + operator. The result is printed using the .numpy() method to convert the tensor to a NumPy array for easy visualization.

47

Resposta de referência

The `.str` accessor is used to apply string methods and functions to elements of a Pandas Series containing string data.

48

Resposta de referência

Scope refers to the region or context in which a variable or name is defined and can be accessed. Python's scope resolution for variable names follows the LEGB rule: Local, Enclosing, Global, and Built-in. Variables defined inside a function are termed Local to that function. They exist only within that function's scope and are inaccessible outside it. Python searches in the Enclosing scope, when a variable is not found in the local scope, which is the scope of any enclosing functions. The search continues to the Global scope, If the variable is not found there, which refers to variables defined at the module level. Python checks the Built-in scope, encompassing built-in functions and attributes, if the variable is still not found. Developers have to be aware of variable naming, to avoid confusion and potential errors and shadowing, especially when using common names that might overlap with built-in functions.

49

Resposta de referência

To create a class, define it using the class keyword. To use a class, create an instance of it, and then you can access its attributes and methods using dot notation.

50

Resposta de referência

Decorators are functions that modify the behavior of another function. They allow for code reuse and separation of concerns by wrapping a function and extending its behavior without permanently modifying it.

51

Resposta de referência

Inheritance gives the power to a class to access all attributes and methods of another class. It aids in code reusability and helps the developer to maintain applications without redundant code. The class inheriting from another class is a child class or also called a derived class. The class from which a child class derives the members are called parent class or superclass. Python supports different kinds of inheritance, they are: - Single Inheritance: Child class derives members of one parent class. # Parent class class ParentClass: def par_func(self): print("I am parent class function") # Child class class ChildClass(ParentClass): def child_func(self): print("I am child class function") # Driver code obj1 = ChildClass() obj1.par_func() obj1.child_func() - Multi-level Inheritance: The members of the parent class, A, are inherited by child class which is then inherited by another child class, B. The features of the base class and the derived class are further inherited into the new derived class, C. Here, A is the grandfather class of class C. # Parent class class A: def __init__(self, a_name): self.a_name = a_name # Intermediate class class B(A): def __init__(self, b_name, a_name): self.b_name = b_name # invoke constructor of class A A.__init__(self, a_name) # Child class class C(B): def __init__(self,c_name, b_name, a_name): self.c_name = c_name # invoke constructor of class B B.__init__(self, b_name, a_name) def display_names(self): print("A name : ", self.a_name) print("B name : ", self.b_name) print("C name : ", self.c_name) # Driver code obj1 = C('child', 'intermediate', 'parent') print(obj1.a_name) obj1.display_names() - Multiple Inheritance: This is achieved when one child class derives members from more than one parent class. All features of parent classes are inherited in the child class. # Parent class1 class Parent1: def parent1_func(self): print("Hi I am first Parent") # Parent class2 class Parent2: def parent2_func(self): print("Hi I am second Parent") # Child class class Child(Parent1, Parent2): def child_func(self): self.parent1_func() self.parent2_func() # Driver's code obj1 = Child() obj1.child_func() - Hierarchical Inheritance: When a parent class is derived by more than one child class, it is called hierarchical inheritance. # Base class class A: def a_func(self): print("I am from the parent class.") # 1st Derived class class B(A): def b_func(self): print("I am from the first child.") # 2nd Derived class class C(A): def c_func(self): print("I am from the second child.") # Driver's code obj1 = B() obj2 = C() obj1.a_func() obj1.b_func() #child 1 method obj2.a_func() obj2.c_func() #child 2 method

52

Resposta de referência

A shallow copy of an object creates a new object but does not create copies of the objects contained within the original object. In contrast, a deep copy creates a new object and recursively creates copies of all objects contained within the original object.

53

Resposta de referência

Python 2 is no longer supported, and Python 3 introduced changes like print() as a function, Unicode as the default string type, and improved syntax.

54

Resposta de referência

Descriptors are objects defining methods like `__get__` and `__set__` to customize attribute access in classes, allowing you to define properties, validators, and more.

55

Resposta de referência

Python supports multiple inheritance through its class definition mechanism. A class can inherit attributes and methods from more than one parent class in Python. This allows for creating a new class that possesses combined characteristics of all its parent classes. Multiple inheritance can introduce ambiguity, especially if two parent classes have attributes or methods with the same name. Python uses the C3 Linearization or Method Resolution Order (MRO) to resolve this. The MRO ensures a specific order in which base classes are accessed. You can view this order using the `mro()` method or the `.__mro__` attribute of a class. Multiple inheritance offers a way to combine functionalities of several classes, and Python provides tools to manage the complexities that arise from it. Your engineers should not be hiring. They should be coding. Help your team focus on what they were hired for. Flexiple will manage your entire hiring process and scale your tech team.

56

Resposta de referência

Multithreading in Python is achieved using the threading module, which allows multiple threads to run concurrently within a single process. However, due to the Global Interpreter Lock (GIL), it is limited for CPU-bound tasks but effective for I/O-bound operations.

57

Resposta de referência

Use the def keyword. Example: def greet(name): return f"Hello, {name}!" print(greet("Alice")) # Hello, Alice!

58

Resposta de referência

A dictionary in Python is an unordered collection of key-value pairs. It is defined using curly braces {}.

59

Resposta de referência

__new__() is responsible for actually creating the object, while __init__() is used to set up or initialize the object after it is created, __new__() runs first and must return the new object, while __init__() does not return anything, and in most real projects developers only use __init__() unless they are doing something very special like creating immutable objects. class Demo: def __new__(cls): print("Creating object") return super().__new__(cls) def __init__(self): print("Initializing object") d = Demo()

60

Resposta de referência

Virtual environments isolate project dependencies, preventing conflicts. You create them using `venv` or `` virtualenv ```, and activate/deactivate them accordingly.

61

Resposta de referência

A stack can be implemented using lists with append() for push operations and pop() for pop operations.

62

Resposta de referência

Python has become the lingua franca for AI projects due to its simplicity and versatility. It offers a rich ecosystem of libraries and frameworks designed for AI and ML tasks, such as TensorFlow, PyTorch, and Keras, which simplify implementing complex algorithms and neural network architectures. Key advantages include readability and ease of use, allowing quick prototyping and iteration. Python's clean syntax and intuitive commands lower the barrier to entry for newcomers. Python is supported by a vast community of developers and researchers who continually contribute to AI tools and libraries, ensuring they are robust, reliable, and up-to-date. Integration with other languages and tools is critical. Python can be used with C/C++ libraries or Java interfaces for optimizing performance-critical parts of AI applications, essential for scaling or integrating with existing systems. While Python may not always be the fastest language, time saved in coding and debugging often outweighs execution time. Python can scale and handle large datasets crucial for AI. Cloud-based AI services with Python APIs have further solidified Python's position, making it straightforward to deploy models and leverage powerful computational resources without extensive infrastructure investment.

63

Resposta de referência

def is_palindrome(s): return s == s[::-1]

64

Resposta de referência

Python manages memory in the Python private heap space. Pythons memory manager and garbage collector control the private heap space. There are multiple levels of scope that can be used in conjunction with namespace, including Built-In, Global, Enclosed, and Local.

65

Resposta de referência

Memory in Python is managed automatically through a private heap space. The Python memory manager handles allocation and deallocation, and a garbage collector reclaims memory from objects that are no longer referenced, using reference counting and cycle detection.

66

Resposta de referência

You can use the `.drop_duplicates()` method to remove duplicate rows based on specific columns. You can also use the `.duplicated()` method to identify duplicates.

67

Resposta de referência

Use various tools and techniques specific to the Python ecosystem, to debug a Python program. The built-in `pdb` module is one of the most popular debugging tools in Python. You initiate it with the `pdb.set_trace()` command within your code. The debugger will start, Once this command is reached during execution, allowing you to inspect variables, execute statements, and control the flow of the program. Use the `print` function to display variable values and track the execution flow. This technique isknown as "print debugging", and is simple yet effective for identifying logical errors or unexpected behaviors. Logging, using Python's `logging` module, is another approach to record the flow of your application and any potential anomalies. IDEs like PyCharm or Visual Studio Code offer integrated debugging tools for more advanced debugging needs. These IDEs provide features like breakpoints, variable watches, and step-through execution. Employ these tools to gain deeper insights into your code and fix issues efficiently.

68

Resposta de referência

In order to use arrays in Python, one must import either an array module or a NumPy package, whereas lists are already built into the language and do not require declaration.

69

Resposta de referência

Sample Answer: Using the quickselect algorithm, similar to quicksort, you can find the kth smallest element in linear time on average. This can be used to compute the median. For example: import random def quickselect(arr, k): if len(arr) == 1: return arr[0] pivot = random.choice(arr) lows = [x for x in arr if x < pivot] highs = [x for x in arr if x > pivot] pivots = [x for x in arr if x == pivot] if k < len(lows): return quickselect(lows, k) elif k < len(lows) + len(pivots): return pivots[0] else: return quickselect(highs, k - len(lows) - len(pivots)) def find_median(nums): n = len(nums) if n % 2 == 1: return quickselect(nums, n // 2) else: return (quickselect(nums, n // 2 - 1) + quickselect(nums, n // 2)) / 2

70

Resposta de referência

One common pitfall is blocking operations within an async function, which can cause event loop contention. To avoid this, we use async-friendly libraries and techniques like asyncio's await keyword and asyncio.gather() for concurrent operations.

71

Resposta de referência

The raise keyword in Python is used to manually raise an exception. It can be used to handle specific error conditions that may not be handled by the built-in exception types or to create custom exceptions.

72

Resposta de referência

The asyncio module is a library in Python that provides support for asynchronous programming using the async/await.

73

Resposta de referência

- Lists, tuples, dictionaries, sets, strings, numbers, Booleans. Each has specific properties and uses.

74

Resposta de referência

A decorator is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure. Decorators are usually called before the definition of a function you want to decorate.

75

Resposta de referência

data = {'Name': ['Alice', 'Bob', 'Carol'], 'Age': [25, 30, 27]} df = pd.DataFrame(data)

76

Resposta de referência

Python is most often used for building software applications, shells of operating systems, pages within a web browser, and for some types of games.

77

Resposta de referência

- List: Mutable (it can be changed), defined with square brackets [ ] - Tuple: Immutable (it can not be changed), defined with parentheses () Example: my_list = [1, 2, 3] my_tuple = (1, 2, 3)

78

Resposta de referência

Pandas provides several key features for data analysis, including data reading and writing, data cleaning and preprocessing, data merging and joining, and data reshaping and pivoting. It also provides powerful indexing and selection capabilities and tools for dealing with missing and time-series data.

79

Resposta de referência

- Best to calculate accuracy, precision, and recall for a classification model using scikit-learn. from sklearn.metrics import accuracy_score, precision_score, recall_score # Sample true labels and predicted labels y_true = [0, 1, 1, 0, 1, 1, 0, 0, 1, 0] y_pred = [0, 0, 1, 0, 1, 1, 1, 0, 1, 0] # Calculating metrics accuracy = accuracy_score(y_true, y_pred) precision = precision_score(y_true, y_pred) recall = recall_score(y_true, y_pred) # Displaying the results print(f'Accuracy: {accuracy:.2f}, Precision: {precision:.2f}, Recall: {recall:.2f}') - accuracy_score computes the proportion of correct predictions. - precision_score measures the ratio of true positives to predicted positives. - recall_score calculates the ratio of true positives to actual positives.

80

Resposta de referência

Example: Given array: [[35 53 63] [72 12 22] [43 84 56]] New Column values: [ 20 30 40 ] Solution: import numpy as np #inputs inputArray = np.array([[35,53,63],[72,12,22],[43,84,56]]) new_col = np.array([[20,30,40]]) # delete 2nd column arr = np.delete(inputArray , 1, axis = 1) #insert new_col to array arr = np.insert(arr , 1, new_col, axis = 1) print (arr)

81

Resposta de referência

A Python program to produce a star triangle can use nested loops. For example, for i in range(1, n+1): print('*' * i) prints a right triangle of stars. A centered triangle can be achieved using string formatting with spaces.

82

Resposta de referência

You use package managers like `pip` to install packages. A virtual environment is an isolated Python environment that allows you to manage dependencies for a specific project.

83

Resposta de referência

- Answer: I'd analyze the code for bottlenecks using profiling tools like cProfile or line_profiler. Based on the results, I'd optimize algorithms, utilize vectorized operations, memoization, and data caching techniques.

84

Resposta de referência

For example, consider an array arr. arr = np.array([[8, 3, 2], [3, 6, 5], [6, 1, 4]]) Let us try to sort the rows by the 2nd column so that we get: [[6, 1, 4], [8, 3, 2], [3, 6, 5]] We can do this by using the sort() method in numpy as: import numpy as np arr = np.array([[8, 3, 2], [3, 6, 5], [6, 1, 4]]) #sort the array using np.sort arr = np.sort(arr.view('i8,i8,i8'), order=['f1'], axis=0).view(np.int) We can also perform sorting and that too inplace sorting by doing: arr.view('i8,i8,i8').sort(order=['f1'], axis=0)

85

Resposta de referência

The code is incorrect because a is updated before calculating the new value of b. This causes the original value of a to be lost, so b is computed using the updated a instead of the previous one. As a result, the sequence becomes 0, 1, 2, 4, 8, ... instead of the Fibonacci sequence. To fix this, both variables should be updated simultaneously using tuple assignment. This preserves the original values during the update and correctly generates the Fibonacci sequence.

86

Resposta de referência

1. Encapsulation: Encapsulation is the process of hiding the internal implementation details of an object and exposing only the necessary information. It helps in achieving data security and code maintainability. Ex- class Car: def __init__(self, brand, model): self.brand = brand self.model = model def start_engine(self): print("Engine started.") my_car = Car("Ford", "Mustang") print(my_car.brand) Output: Ford my_car.start_engine() #Output: Engine started 2. Inheritance: Inheritance is a mechanism where a class inherits properties and methods from a parent class. It allows code reuse and the creation of specialized classes based on more general classes. Ex- class Animal: def __init__(self, name): self.name = name def speak(self): print("Animal speaks.") class Dog(Animal): def speak(self): print("Woof!") my_dog = Dog("Buddy") print(my_dog.name) Output: Buddy my_dog.speak() #Output: Woof! 3. Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common base class. It provides flexibility and extensibility in handling objects of different types. Ex- class Shape: def area(self): pass class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height class Circle(Shape): def __init__(self, radius): self.radius = radius def area(self): return 3.14 * self.radius ** 2 shapes = [Rectangle(4, 5), Circle(3)] for shape in shapes: print(shape.area()) 4. Abstraction: Abstraction involves representing essential features of an object while hiding the unnecessary details. It allows programmers to work with high-level concepts without worrying about implementation specifics. Ex- from abc import ABC, abstractmethod class Shape(ABC): def area(self): pass class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height class Circle(Shape): def __init__(self, radius): self.radius = radius def area(self): return 3.14 * self.radius ** 2 my_rectangle = Rectangle(4, 5) my_circle = Circle(3) print(my_rectangle.area()) #Output: 20 print(my_circle.area()) #Output: 28.26

87

Resposta de referência

Given your experience as a Python programmer, you might have your own unique answer to this question. But among whatever other features Python supports that you think are worth mentioning, try to hit upon the following key Python features: - Python is an interpreted language, like PHP and Ruby, that does not need to be compiled before it is run - Python is a good choice for object-oriented programming because of its capacity to define classes along with inheritance and composition - Python is dynamically typed - Writing Python code is comparatively quick - Python is one of the most versatile programming languages and is used for a wide variety of applications including web development, automation, data science, scientific modeling, and many more.

88

Resposta de referência

Data Abstraction is providing only the required details and hiding the implementation from the world. It can be achieved in Python by using interfaces and abstract classes.

89

Resposta de referência

The Lambda function is also known as an anonymous function. You can add any number of parameters, but with only one statement. An iterator is an object that we can use to iterate over iterable objects like lists, dictionaries, tuples, and sets. The generator is a function similar to a normal function, but it generates a value using the yield keyword instead of return. If the function body contains yield, it automatically becomes a generator.

90

Resposta de referência

A lambda function is a small anonymous function in Python that can have any number of arguments, but can only have one expression. The main difference between a lambda function and a regular function is that a lambda function is defined inline, without a name, and is typically used as a simple, one-line function that is not reusable.

91

Resposta de referência

Solution: def decimal_to_binary(decimal): binary = "" quotient = decimal while quotient > 0: remainder = quotient % 2 binary = str(remainder) + binary quotient //= 2 return binary # Example usage decimal_number = 10 binary_number = decimal_to_binary(decimal_number) print("Binary representation of", decimal_number, "is", binary_number) Output: Binary representation of 10 is 1010

92

Resposta de referência

- Use save_screenshot() method to capture entire page or element.screenshot() for specific elements. - Integrate screenshots into test reports for visual evidence of failures.

93

Resposta de referência

Errors and exceptions can be handled in Python using the try-except block. The try block contains the code that might raise an exception, and the except block catches the exception if it occurs. This allows the program to gracefully handle errors and continue executing the code without crashing.

94

Resposta de referência

from datetime import datetime print("Current time is:", datetime.now()) Output Current time is: 2026-05-11 11:10:41.581886

95

Resposta de referência

def fibonacci(n): sequence = [0, 1] for _ in range(2, n): sequence.append(sequence[-1] + sequence[-2]) return sequence[:n] print(fibonacci(7)) # [0, 1, 1, 2, 3, 5, 8]

96

Resposta de referência

You can use the + operator or string formatting, like this: name = "John" greeting = "Hello, " + name

97

Resposta de referência

The pass statement in Python is a no-operation statement used as a placeholder when a statement is syntactically required but no action is needed. It is commonly used as a placeholder for code that will be implemented later.

98

Resposta de referência

- Answer: Discuss avoiding hardcoding sensitive information like credentials, using environment variables, storing secrets securely, and following secure coding practices for data handling.

99

Resposta de referência

The `.to_csv()` method is used to export a DataFrame to a CSV file, allowing you to save your data for future use.

100

Resposta de referência

Python has cemented its place as a pivotal programming language in the development of emerging technologies, influencing sectors from AI to IoT, data analytics, and cloud computing. Python's simplicity and readability make it ideal for rapid prototyping and development, critical in fast-paced emerging tech environments where being first to market is an advantage. Its extensive library ecosystem provides tools for specific needs, reducing development time. In AI and machine learning, Python is often the language of choice with libraries like TensorFlow, Keras, and PyTorch for building and deploying models. In IoT, Python's versatility allows microcontrollers like Raspberry Pi to run scripts for controlling hardware and managing sensor data, with a shorter learning curve for developers. In data analytics, libraries like Pandas, NumPy, and Matplotlib are staples for efficient data manipulation and visualization. In cloud computing, Python's compatibility with AWS, Google Cloud, and Azure is used for writing automation scripts and building cloud infrastructure, aligning with Infrastructure as Code. In cybersecurity, Python is used to create security scripts, analyze malware, and perform penetration testing. In web development, Django and Flask allow creation of scalable and secure web applications for both startups and large enterprises.

101

Resposta de referência

/ represents precise division (result is a floating point number) whereas // represents floor division (result is an integer). For Example: print(5//2) print(5/2) Output 2 2.5

102

Resposta de referência

A return statement is used to specify the value a function should return. It ends the function's execution.

103

Resposta de referência

Use the join() method to concatenate all elements of a list into a single string: chars = ['P', 'y', 't', 'h', 'o', 'n'] string = ''.join(chars) print(string) # Output: 'Python'

104

Resposta de referência

You have been provided with the list of positive integers from 1 to n. All the numbers from 1 to n are present except x, and you must find x. Example: | 4 | 5 | 3 | 2 | 8 | 1 | 6 | - n = 8 - missing number = 7 This question is a simple math problem. - Find the sum of all elements in the list. - By using arithmetic series sum formula, we will find the expected sum of the first n numbers. - Return the difference between the expected sum and the sum of the elements. def find_missing(input_list): sum_of_elements = sum(input_list) # There is exactly 1 number missing n = len(input_list) + 1 actual_sum = (n * ( n + 1 ) ) / 2 return int(actual_sum - sum_of_elements) list_1 = [1,5,6,3,4] find_missing(list_1) # 2

105

Resposta de referência

Python decorators are a design pattern in Python that allows adding new functionality to an existing object without modifying its structure. Decorators are called before the definition of a function you want to decorate. Decorators are used in scenarios where you want to add a common behavior or modify functionality across multiple functions or methods. Decorators measure the execution time of functions, log function metadata,etc. A decorator is applied using the “@” symbol followed by the decorator name, placed immediately above the function definition. my_function is passed as an argument to my_decorato r, and the result is the modified or enhanced function.

106

Resposta de referência

Sample Input: 3 odd 2 even 3 odd 5 Sample Output: 1 3 0 2 4 1 3 5 7 9 Explanation: In the first query, print_from_stream(2, OddStream()) is executed, printing 1 and 3 as the first two non-negative odd numbers. In the second query, print_from_stream(3) is executed, printing 2, 4 and 6 as the first three non-negative even numbers. In the third query, print_from_stream(5, OddStream()) is executed, printing 1, 3, 5, 7 and 9 as the first five non-negative odd numbers.

107

Resposta de referência

Python supports multiple inheritance by allowing a class to inherit attributes and methods from more than one parent class. The method resolution order (MRO) determines the order in which base classes are accessed.

108

Resposta de referência

Parameters are variables defined in a function's declaration, while arguments are values passed to a function when it's called.

109

Resposta de referência

To create a custom exception class, inherit from the built-in Exception class or one of its subclasses.

110

Resposta de referência

Python was developed by Guido van Rossum and was first introduced on February 20, 1991.

111

Resposta de referência

You can use a try-except block. Example: try: result = 10 / 0 except ZeroDivisionError: print("Cannot divide by zero.")

112

Resposta de referência

Dictionary and list comprehensions are just another concise way to define dictionaries and lists. Example of list comprehension is- x=[i for i in range(5)] The above code creates a list as below- 4 [0,1,2,3,4] Example of dictionary comprehension is- x=[i : i+2 for i in range(5)] The above code creates a list as below- [0: 2, 1: 3, 2: 4, 3: 5, 4: 6]

113

Resposta de referência

- @staticmethod: Does not access the class or instance. It's used for utility functions. - @classmethod: Accesses the class itself as the first argument (cls). Used for alternative constructors. Example: class MyClass: @staticmethod def static_method(): return "I don't use class data!" @classmethod def class_method(cls): return f"I am a method of {cls.__name__}"

114

Resposta de referência

It is an environment variable which is used when a module is imported. Whenever a module is imported, PYTHONPATH is also looked up to check for the presence of the imported modules in various directories. The interpreter uses it to determine which module to load.

115

Resposta de referência

Use multithreading when tasks wait for I/O like files, APIs, or databases. Use multiprocessing for CPU-heavy work like data processing or ML. Threads share memory but are limited by GIL.Processes run in parallel and use multiple CPU cores.Processes use more memory but give better speed for heavy tasks. So choice depends on the type of work. # Multiprocessing example from multiprocessing import Process def work(): print("Heavy task running") p1 = Process(target=work) p2 = Process(target=work) p1.start() p2.start()

116

Resposta de referência

NumPy arrays are more efficient than Python lists for numerical operations, especially for large data sets. They also support vectorized operations, which simultaneously perform operations on entire arrays.

117

Resposta de referência

The `apply()` function is used to apply a function to each element, row, or column of a DataFrame or Series. It is often used for custom data transformations.

118

Resposta de referência

Code reviews are crucial. We use automated tools like linters to catch style issues early. During code reviews, team members provide feedback on adherence to coding standards and best practices, ensuring consistency and quality.

119

Resposta de referência

- Function Annotation is a feature that allows you to add metadata to function parameters and return values. This way you can specify the input type of the function parameters and the return type of the value the function returns. - Function annotations are arbitrary Python expressions that are associated with various parts of functions. These expressions are evaluated at compile time and have no life in Python's runtime environment. Python does not attach any meaning to these annotations. They take life when interpreted by third-party libraries, for example, mypy.

120

Resposta de referência

Python uses a combination of reference counting and garbage collection for memory management. - Reference Counting: Tracks the number of references to an object. If the count drops to zero, the memory is freed. - Garbage Collection: Handles circular references using generational garbage collection, categorizing objects by their lifespan for efficient cleanup.

121

Resposta de referência

To create a new column in a pandas DataFrame using values from existing columns, assign the result of an operation on other columns to a new column name, e.g., df['new_column'] = df['col1'] + df['col2'].

122

Resposta de referência

- Answer: I'd use libraries like openpyxl to manipulate Excel spreadsheets. I'd automate tasks like data extraction, cleaning, formatting, and report generation using loops and conditional statements.

123

Resposta de referência

The `contextlib` module provides utilities for creating context managers using the `with` statement. You can define context managers as functions with the `@contextmanager` decorator.

124

Resposta de referência

PEP 8 is Python's style guide, which provides guidelines for writing readable and consistent code. It is important for maintaining code quality and readability across projects.

125

Resposta de referência

Sample Answer: Binary search is an efficient algorithm for finding a target in a sorted array. It repeatedly divides the search interval in half until the target is found. Here is how to implement a binary search in Python: def binary_search(arr, target): low, high = 0, len(arr) - 1 while low <= high: mid = (low + high) // 2 if arr[mid] < target: low = mid + 1 elif arr[mid] > target: high = mid - 1 else: return mid return -1

126

Resposta de referência

High-level language are first needs to be converted to low-level language e.g. Java Virtual Machine does the Java language. This is an extra step which makes executing code slower compared to low-level language.

127

Resposta de referência

The __str__ method is used to define the string representation of an object, and is typically used for displaying the object to end-users. The __repr__ method, on the other hand, is used to define the "official" string representation of an object, and is typically used for debugging and development purposes. The main difference between the two is that __str__ is called when str() is called on an object, while __repr__ is called when repr() is called on an object.

128

Resposta de referência

In Django, there are three possible inheritance styles:

129

Resposta de referência

It is an environment variable, which is used when a module is imported. Whenever a module is imported, PYTHONPATH is also looked up to check for the presence of the imported modules in various directories. The interpreter uses it to determine which module to load.

130

Resposta de referência

Arrays and lists, in Python, have the same way of storing data. But, arrays can hold only a single data type elements whereas lists can hold any data type elements. Example: import array as arr My_Array=arr.array('i',[1,2,3,4]) My_list=[1,'abc',1.20] print(My_Array) print(My_list) Output: array(‘i', [1, 2, 3, 4]) [1, ‘abc', 1.2]

131

Resposta de referência

Python documentation strings (or docstrings) provide a convenient way of associating documentation with Python modules, functions, classes and methods. - Declaring Docstrings: Docstrings are written using triple single quotes (''') or triple double quotes (""") immediately below the module, class, method or function definition. - Accessing Docstrings: Docstrings can be accessed using the __doc__ attribute of the object or by using the help() function. def add(a, b): """Return the sum of two numbers.""" return a + b # Access using __doc__ print(add.__doc__) # Access using help() help(add) Explanation: In this example, the function add() includes a docstring that describes its purpose. The docstring can be viewed directly using add.__doc__ or through the built-in help() function.

132

Resposta de referência

Scope in Python refers to the region of a program where a variable is accessible. It determines the visibility of variables and is defined by the location where they are declared, such as local, global, or nonlocal scope.

133

Resposta de referência

Encapsulation is the process of hiding the internal state of an object and requiring all interactions to be performed through an object's methods. This approach: - Provides better control over data. - Prevents accidental modification of data. - Promotes modular programming. Python achieves encapsulation through public, protected and private attributes.

134

Resposta de referência

from flask import Flask app = Flask(__name__) @app.route('/') def home(): return "Welcome to Flask!" if __name__ == '__main__': app.run(debug=True) Explanation of solution: A Flask app instance is created. A route '/' is defined using the @app.route decorator. The corresponding view function home returns a simple string. The app.run(debug=True) statement runs the Flask application with debug mode enabled.

135

Resposta de referência

- Answer: I'd use Pandas for data manipulation and analysis. I'd look for patterns in purchase history, demographics, and location data using group-by functions and visualizations. K-means clustering could help identify distinct customer segments for targeted campaigns.

136

Resposta de referência

A class is a blueprint for creating objects (instances). Example: class Dog: def __init__(self, name): self.name = name # Create an instance my_dog = Dog("Rex") print(my_dog.name) # Rex

137

Resposta de referência

We will use the following lines of code: from bs4 import BeautifulSoup import requests import sys url = 'http://www.imdb.com/chart/top' response = requests.get(url) soup = BeautifulSoup(response.text) tr = soup.findChildren("tr") tr = iter(tr) next(tr) for movie in tr: title = movie.find('td', {'class': 'titleColumn'} ).find('a').contents[0] year = movie.find('td', {'class': 'titleColumn'} ).find('span', {'class': 'secondaryInfo'}).contents[0] rating = movie.find('td', {'class': 'ratingColumn imdbRating'} ).find('strong').contents[0] row = title + ' - ' + year + ' ' + ' ' + rating print(row) The above code will help scrap data from IMDb's top 250 list

138

Resposta de referência

Solution: def is_anagram(str1, str2): # Remove spaces and convert to lowercase for case-insensitive comparison str1 = str1.replace(" ", "").lower() str2 = str2.replace(" ", "").lower() # Check if the sorted forms of both strings are equal return sorted(str1) == sorted(str2) # Example usage string1 = "listen" string2 = "silent" if is_anagram(string1, string2): print(f"'{string1}' and '{string2}' are anagrams.") else: print(f"'{string1}' and '{string2}' are not anagrams.") Output: 'listen' and 'silent' are anagrams.

139

Resposta de referência

Basic algorithm - From each of the unvisited vertices, choose the vertex with the smallest distance and visit it. - Update the distance for each neighboring vertex, of the visited vertex, whose current distance is greater than its sum and the weight of the edge between them. - Repeat steps 1 and 2 until all the vertices are visited. Here's the implementation import sys # Function to find out which of the unvisited node # needs to be visited next def to_be_visited(): global visited_and_distance v = -10 # Choosing the vertex with the minimum distance for index in range(number_of_vertices): if visited_and_distance[index][0] == 0 \ and (v < 0 or visited_and_distance[index][1] <= \ visited_and_distance[v][1]): v = index return v # Creating the graph as an adjacency matrix vertices = [[0, 1, 1, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0]] edges = [[0, 3, 4, 0], [0, 0, 0.5, 0], [0, 0, 0, 1], [0, 0, 0, 0]] number_of_vertices = len(vertices[0]) # The first element of the lists inside visited_and_distance # denotes if the vertex has been visited. # The second element of the lists inside the visited_and_distance # denotes the distance from the source. visited_and_distance = [[0, 0]] for i in range(number_of_vertices-1): visited_and_distance.append([0, sys.maxsize]) for vertex in range(number_of_vertices): # Finding the next vertex to be visited. to_visit = to_be_visited() for neighbor_index in range(number_of_vertices): # Calculating the new distance for all unvisited neighbours # of the chosen vertex. if vertices[to_visit][neighbor_index] == 1 and \ visited_and_distance[neighbor_index][0] == 0: new_distance = visited_and_distance[to_visit][1] \ + edges[to_visit][neighbor_index] # Updating the distance of the neighbor if its current distance # is greater than the distance that has just been calculated if visited_and_distance[neighbor_index][1] > new_distance: visited_and_distance[neighbor_index][1] = new_distance # Visiting the vertex found earlier visited_and_distance[to_visit][0] = 1 i = 0 # Printing out the shortest distance from the source to each vertex for distance in visited_and_distance: print("The shortest distance of ",chr(ord('a') + i),\ " from the source vertex a is:",distance[1]) i = i + 1 Output: The shortest distance of a from the source vertex a is: 0 The shortest distance of b from the source vertex a is: 3 The shortest distance of c from the source vertex a is: 3.5 The shortest distance of d from the source vertex a is: 4.5

140

Resposta de referência

- Small, anonymous functions defined in one line using lambda keyword. Useful for concise, one-time function use.

141

Resposta de referência

The limitations of the GIL can be overcome by using multiprocessing instead of threading, or by using external libraries that are designed to work around the GIL, such as numpy, pandas, and matplotlib.

142

Resposta de referência

A Series is a one-dimensional data structure, while a DataFrame is a two-dimensional data structure. A DataFrame is essentially a collection of Series objects, and you can think of it as a table.

143

Resposta de referência

In Python, shallow and deep copies are used to duplicate objects, but they handle nested structures differently. - Shallow Copy: A shallow copy creates a new object but inserts references to the objects found in the original. So, if the original object contains other mutable objects (like lists within lists), the shallow copy will reference the same inner objects. This can lead to unexpected changes if you modify one of those inner objects in either the original or copied structure. You can create a shallow copy using the copy() method or the copy module's copy() function. - Deep Copy: A deep copy creates a new object and recursively copies all objects found within the original. This means that even nested structures get duplicated, so changes in one copy don't affect the other. To create a deep copy, you can use the copy module's deepcopy() function. So, a shallow copy is suitable when the object contains only immutable items or when you want changes in nested structures to reflect in both copies. A deep copy is ideal when working with complex, nested objects where you want a completely independent duplicate.

144

Resposta de referência

*args is used to pass a variable number of non-keyword arguments to a function. It allows you to pass any number of arguments to a function by putting them in a tuple. **kwargs is used to pass a variable number of keyword arguments to a function. It allows you to pass any number of key-value pairs to a function by putting them in a dictionary.

145

Resposta de referência

def is_palindrome(s): return s == s[::-1]

146

Resposta de referência

Sample Answer: Dijkstra's algorithm is used to find the shortest path from a starting node to all other nodes in a weighted graph. Here's how you can implement it: import heapq def dijkstra(graph, start): min_heap = [(0, start)] distances = {node: float('inf') for node in graph} distances[start] = 0 while min_heap: current_distance, current_node = heapq.heappop(min_heap) if current_distance > distances[current_node]: continue for neighbor, weight in graph[current_node].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(min_heap, (distance, neighbor)) return distances

147

Resposta de referência

__slots__ is used to limit what attributes an object can have, it stops Python from creating a normal dictionary for each object, which saves memory, and also makes attribute access a little faster, this is useful when you create a very large number of small objects, but the downside is you lose flexibility because you cannot add new attributes freely. class Point: __slots__ = ("x", "y") def __init__(self, x, y): self.x = x self.y = y p = Point(1, 2)

148

Resposta de referência

Developers can create functions in Python by following the steps below: - Declare the function by entering the keyboard def followed by its name. - Write the arguments within the open and close parentheses of the function and end it with a colon. - Add the program statements that will be executed when the function is called.

149

Resposta de referência

The super() function is used to call a method from a parent class within a subclass. It is often used in the __init__() method of a subclass to invoke the parent class's __init__() method, ensuring that the initialization logic of both classes is executed.

150

Resposta de referência

Output : Using in-build syntax : a is 20 & b is 10 Using arithmetic operations : a is 20 & b is 10

151

Resposta de referência

print(sum(range(25,76)))

152

Resposta de referência

Python advantages include its simple and readable syntax, extensive standard library, cross-platform compatibility, strong community support, and suitability for diverse applications like web development, data science, and machine learning.

153

Resposta de referência

- Process: Independent execution unit with its own memory space. Created using the multiprocessing module. - Thread: Lightweight unit within a process sharing the same memory space. Managed using the threading module.

154

Resposta de referência

We typically use a version control system like Git to track changes in the requirements.txt file. Additionally, we encourage developers to regularly update it when adding or updating dependencies, and use tools like pip-tools to manage dependencies consistently.

155

Resposta de referência

sequence = input ("Enter a sequence = ") reversed_sequence = sequence[::-1] if sequence == reverse_sequence: print("Palindrome Sequence.") else: print("Not a Palindrome.")

156

Resposta de referência

The location where we can find a variable and also access it if required is called the scope of a variable. - Python Local variable: Local variables are those that are initialized within a function and are unique to that function. A local variable cannot be accessed outside of the function. - Python Global variables: Global variables are the ones that are defined and declared outside any function and are not specified to any function. - Module-level scope: It refers to the global objects of the current module accessible in the program. - Outermost scope: It refers to any built-in names that the program can call. The name referenced is located last among the objects in this scope.

157

Resposta de referência

This can be easily done by making use of the isalnum() method that returns true in case the string has only alphanumeric characters. For Example - "abdc1321".isalnum() #Output: True "xyz@123$".isalnum() #Output: False Another way is to use match() method from the re (regex) module as shown: import re print(bool(re.match('[A-Za-z0-9]+$','abdc1321'))) # Output: True print(bool(re.match('[A-Za-z0-9]+$','xyz@123$'))) # Output: False

158

Resposta de referência

- *args: Passes a variable number of positional arguments. - **kwargs: Passes a variable number of keyword arguments. Example: def greet(*args, **kwargs): print(args) print(kwargs) greet("Hello", "World", name="Alice", age=25) # ('Hello', 'World') # {'name': 'Alice', 'age': 25}

159

Resposta de referência

The dir() function can be accessed from the Python interpreter, and it is used to access built-in functions of modules and packages. It is used to display the defined symbols.

160

Resposta de referência

GIL is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes simultaneously, which can be a bottleneck in CPU-bound multithreaded programs.

161

Resposta de referência

Solution: def is_leap_year(year): if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): return True else: return False # Example usage input_year = 2024 if is_leap_year(input_year): print(input_year, "is a leap year.") else: print(input_year, "is not a leap year.") Output: 2024 is a leap year.

162

Resposta de referência

A regular expression (regex or regexp for short) is a special text string for describing a search pattern. You can think of regular expressions as wildcards on steroids. You are probably familiar with wildcard notations such as *.txt to find all text files in a file manager.

163

Resposta de referência

Provide specific examples, such as taking ownership of certain modules, ensuring code integration, or mentoring junior team members.

164

Resposta de referência

When you change a list while looping over it, the indexes shift, so some items get skipped or processed twice, this leads to strange bugs that are hard to see, the safe way is to loop over a copy or build a new list. nums = [1, 2, 3, 4] for n in nums: if n % 2 == 0: nums.remove(n) print(nums) # [1, 3] but logic is broken for bigger cases # Safe way nums = [1, 2, 3, 4] for n in nums[:]: if n % 2 == 0: nums.remove(n) print(nums) # [1, 3]

165

Resposta de referência

The try and except keywords in Python are used to handle runtime errors that may occur during the execution of a program. The try block contains the code that may raise an exception, and the except block contains the code that is executed if an exception is raised.

166

Resposta de referência

String indexing allows you to access individual characters, while slicing lets you extract substrings using a range of indices.

167

Resposta de referência

The sorted() function returns a new sorted list from the elements of any iterable. It has parameters for specifying the sorting order and key functions.

168

Resposta de referência

HTTP (Hypertext Transfer Protocol) acts as the foundation for any web application built with Python. Python frameworks, such as Flask and Django, utilize this protocol to communicate between the client's browser and the web server. The browser sends an HTTP request to the server, when a user requests a page. Python web frameworks process this request, fetch the necessary data from the database, and then send back an HTTP response containing the web page's content. The content displays in the user's browser. Python frameworks use routing, to handle different types of requests. Routing directs an incoming request to the correct function or method based on the URL and the request method. This allows for dynamic page rendering and interaction, ensuring users see the right content based on their actions.

169

Resposta de referência

The Python str function will convert an object to a string. dict={'first':'Bob', 'last':'Smith'} str(dict)

170

Resposta de referência

Default arguments are created only once, not every time the function runs, so if you use a list or dict as a default and change it, the change stays for the next call, this causes strange bugs where old data appears again, so the safe way is to use None and create a new list inside the function. def add_item(item, items=[]): items.append(item) return items print(add_item(1)) print(add_item(2)) # [1, 2] unexpected def safe_add(item, items=None): if items is None: items = [] items.append(item) return items

171

Resposta de referência

The benefits of using python are-

172

Resposta de referência

Sample Answer: You can use a method called the sliding window technique, which helps keep track of a range of unique characters. The window is adjusted when a repeated character is found, and you keep track of the longest length of this window to determine the longest substring without repeating characters. Here's how you can write the code to find that substring without repeating characters: def length_of_longest_substring(s): char_index = {} max_length = start = 0 for index, char in enumerate(s): if char in char_index and char_index[char] >= start: start = char_index[char] + 1 char_index[char] = index max_length = max(max_length, index - start + 1) return max_length

173

Resposta de referência

Global variables are declared outside any function or block and can be accessed from anywhere within the program. They have a global scope, meaning they are visible to all functions and blocks within the program. Ex: x = 10 def print_global(): print(x) print_global() # Output: 10 Local variables are declared within a function or block and can only be accessed within that specific function or block. They have a local scope, meaning they are visible and accessible only within their respective function or block. Ex: def print_local(): y = 20 print(y) print_local() # Output: 20

174

Resposta de referência

def fibonacci(n): sequence = [0, 1] for _ in range(2, n): sequence.append(sequence[-1] + sequence[-2]) return sequence[:n] print(fibonacci(7)) # [0, 1, 1, 2, 3, 5, 8]

175

Resposta de referência

Handling file uploads in Python web applications involves using specific libraries and frameworks. Flask and Django are two popular frameworks that offer solutions for this. The `FileField` and `ImageField` in the model can be used to manage file uploads in Django. Django saves it to the specified location on the server, when a user submits a form containing a file. Middleware such as `django.middleware.security.SecurityMiddleware` ensures the security of uploaded files. The `request` object provides access to uploaded files in Flask. The `save()` method is used to save these files to the server. Ensure proper validation of file types and sizes in Flask to prevent malicious uploads. Use the `secure_filename()` function from the `werkzeug.utils` module to guarantee a secure file name.

176

Resposta de referência

To perform a binary search in a sorted list, divide the list into two halves and determine which half the desired element might be in. Compare the desired element to the middle element, starting with the entire list. Focus on the first half of the list, If the desired element is less than the middle element. Focus on the second half, if it's greater. Repeat this process, halving the section of interest, until you find the desired element or the section of interest is empty. You can implement this algorithm using iterative or recursive methods. The key is to maintain low and high pointers, adjusting them based on the comparison with the middle element. The search ends when the low pointer exceeds the high pointer or the desired element is found. Leverage built-in modules like 'bisect', For optimal performance in Python. This module provides tools for working with sorted lists and offers binary search functionalities.

177

Resposta de referência

An exception is an error that occurs while the program is executing. When this error occurs, the program will stop and generate an exception which then gets handled in order to prevent the program from crashing. The exceptions generated by a program are caught in the try block and handled in the except block. Try : Lets you test a block of code for errors.Except : Lets you handle the error.

178

Resposta de referência

The GIL is a mutex that allows only one thread to execute Python bytecode at a time, limiting multi-threaded performance for CPU-bound tasks.

179

Resposta de referência

Sample Answer: Rotating a list to the right by k steps means shifting its elements to the right, such that the last k elements wrap around to the front of the list. This operation can be efficiently achieved using slicing in Python. Here's how you can implement a function to rotate a list: def rotate(lst, k): k = k % len(lst) return lst[-k:] + lst[:-k]

180

Resposta de referência

You use a stack, when you see an opening bracket you push it, when you see a closing one you check if it matches the last opening bracket, if not it is invalid, at the end the stack must be empty, this works for (), {}, and []. def is_valid(s): stack = [] pairs = {')': '(', '}': '{', ']': '['} for ch in s: if ch in pairs.values(): stack.append(ch) elif ch in pairs: if not stack or stack.pop() != pairs[ch]: return False return not stack print(is_valid("()[]{}")) # True print(is_valid("(]")) # False

181

Resposta de referência

Python is considered to be a multi-paradigm language, which means it supports multiple programming techniques including object-oriented and functional programming. Since most Python tools have bundled up data and functions, it is considered to be object-oriented. The functions of Python are important for data scientists and programmers alike because Python supports both object-oriented and functional programming.

182

Resposta de referência

A Series is a one-dimensional labeled array capable of holding data of any type. It is similar to a column in a spreadsheet or a single column in a DataFrame.

183

Resposta de referência

- Mutable data types are objects whose values can be changed after they are created. Any modification is made in place without creating a new object. Common examples include lists, dictionaries and sets. - Immutable data types are objects whose values cannot be changed after creation. If you modify them, Python creates a new object instead. Common examples include strings, tuples, integers and floats. # Mutable example a = [1, 2, 3] a.append(4) print(a) # Immutable example s = "Hello" s = s + " World" print(s) Explanation: In the first example, the list a is modified directly by adding a new element. In the second example, strings are immutable, so concatenating " World" creates a new string object and assigns it back to s.

184

Resposta de referência

Python uses reference counting to track object references. Garbage collection is used to reclaim memory from objects with zero references.

185

Resposta de referência

staticmethod is a method that does not operate on an instance or class; it's just a function in the class's namespace. classmethod takes the class as its first argument and can modify class state.

186

Resposta de referência

I once worked on a web scraping project where I used async/await for concurrent HTTP requests, optimized CPU-bound tasks using multiprocessing, and utilized caching to reduce network calls.

187

Resposta de referência

The code looks correct, but there is no error handling for situations where the user tries to withdraw more money than they have in their account. To fix this, we can add a check in the withdraw method to ensure that the amount being withdrawn does not exceed the current balance: class BankAccount: def __init__(self, balance): self.balance = balance def deposit(self, amount): self.balance += amount def withdraw(self, amount): if amount > self.balance: raise ValueError("Insufficient funds") self.balance -= amount def check_balance(self): print("Your balance is: ", self.balance)

188

Resposta de referência

NumPy improves performance in Python through its optimized C libraries and efficient data structures. Numpy is able to divide a task into multiple subtasks and process them parallelly. NumPy arrays are more compact and faster than Python lists. Their fixed type nature allows them to be stored in contiguous blocks of memory. Accelerating operations on the arrays, this memory layout enhances cache coherence. NumPy's typed arrays eliminate type-checking overheads during runtime, in contrast to Python's dynamic typing. NumPy employs optimized C and Fortran libraries for mathematical operations. This ensures that calculations are offloaded to these underlying optimized routines, rather than relying on slower Python loops, when performing operations on large datasets. This offloading becomes evident in speed improvements, especially for operations like matrix multiplication or element-wise computations. NumPy offers significant performance enhancements for numerical computations in Python, through its specialized array data structures and leveraging lower-level optimized libraries.

189

Resposta de referência

You can use Python package managers like pip or conda to install external packages. Specify the package name and version to install.

190

Resposta de referência

You can send emails using Python by leveraging the built-in `smtplib` library. This library defines an SMTP client session object that can be used to send emails to any internet machine with an SMTP or ESMTP listener daemon. Begin by establishing a connection to your email service provider's SMTP server. Set up the SMTP server, provide the necessary credentials, and choose the appropriate port. Once connected,construct your email using the `email.mime.text` module to format the email content. After crafting the email, use the `sendmail` method to send it. Remember to close the connection after sending the email. Using `smtplib` and `email.mime.text`, Python provides a straightforward way to automate and send emails programmatically.

191

Resposta de referência

Pickling pertains to the serialization of Python objects into a string (or any other format) so that they can be persisted on storage or transmitted through a network. Unpickling refers to the restoration of pickled string into the original object.

192

Resposta de referência

In python, arguments are passed through reference. This means that when a function is called and an argument is passed, a reference to the object is passed in place of the value itself.

193

Resposta de referência

You can use the try, except blocks to handle exceptions in Python. The code inside the try block is executed, and if an exception occurs, it is caught by the corresponding except block. try: result = 10 / 0 except ZeroDivisionError: print("Cannot divide by zero!")

194

Resposta de referência

- for loop: Iterates through a sequence of elements. - while loop: Executes a block of code repeatedly while a condition is true. - nested loops: Loops within loops for complex iteration needs.

195

Resposta de referência

The Pandas library in Python is used for working with data sets and analysis. Pandas provides data structures like Series and DataFrame, facilitating the efficient handling of large datasets. It offers functionalities like indexing, grouping, and merging, making it easier to clean, transform, and visualize data. Reading from and writing to diverse file formats becomes straightforward with Pandas. Pandas streamlines the process, whether you're handling CSV files, Excel spreadsheets, or SQL databases. Analyzing data with Pandas becomes a more intuitive and efficient task for developers.

196

Resposta de referência

The Python language has the following multi-threading tools: - A designated multi-threading package. It's not widely used as it slows code execution down. - GIL (Global Interpreter Lock) constructor. It helps ensure that only one string is executed at a time. After GIL executes a string, it'll get passed over to the next one. Thus, while there's an illusion of parallelism (multiple strings running synchronously), the truth is, threads take turns during execution. However, the process is so fast that it's barely distinguishable to the human eye.

197

Resposta de referência

List - Lists are Mutable datatype. - Lists consume more memory - The list is better for performing operations, such as insertion and deletion. - The implication of iterations is Time-consuming Tuple - Tuples are Immutable datatype. - Tuple consumes less memory as compared to the list - A Tuple data type is appropriate for accessing the elements - The implication of iterations is comparatively Faster

198

Resposta de referência

A singleton pattern in Python ensures that only one instance of a class exists throughout the program. One common way to implement it is using a metaclass. The metaclass overrides the __call__ method to control instance creation, storing a single instance in a class-level dictionary. class Singleton(type): _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs) return cls._instances[cls] class MyClass(metaclass=Singleton): pass a = MyClass() b = MyClass() print(a is b) # True

199

Resposta de referência

__name__ is a built-in variable that returns the name of the current module. It helps determine if a module is being run standalone or imported elsewhere.

200

Resposta de referência

A shallow copy constructs a new collection object and inserts references into it to the objects found in the original. A deep copy constructs a new collection object and recursively inserts copies into it of the objects found in the original.

NÃO QUER PERDER NADA?

Os testes práticos Cisco, PMP, CISA, CISM e AWS 100% aprovados estão à venda!
Obtenha agora

Obtenha uma certificação para destacar o seu currículo.

NÃO QUER PERDER NADA?

Os testes práticos Cisco, PMP, CISA, CISM e AWS 100% aprovados estão à venda! Obtenha agora

Obtenha uma certificação para destacar o seu currículo.

Os testes práticos Cisco, PMP, CISA, CISM e AWS 100% aprovados estão à venda!
Obtenha agora