Uncategorized

Thread interview questions: We have compiled most frequently asked Python Interview Questions which will help you with different expertise levels.

You can also find out what is multithreading in python, Multithreading in c interview questions, Python interview questions for managers, Python loops interview questions, Multithreading interview questions c, Python multithreading subjective question, Python architect interview questions, Python concurrency interview questions, Multithreading in c# interview questions, multithreading interview questions c++, python interview questions on multithreading, python thread interview questions, Python threading questions, python multithreading interview questions.

Python Interview Questions on Python Thread Management

Question 1.
What are Python threads?
Answer:
Multiple streams of execution. Often used to handle multiple simultaneous requests or processing tasks. 1

122: What is a race condition?
Answer:
A race condition occurs when two or more threads are competing for the same resource, and cannot continue without \ it. This is also called a deadlock.

Question 3.
How is a new thread started?
Answer: :
By invoking the .start _new_thread( ) method of the thread module.

Question 4:
What happens to other threads if a thread in a program encounters an exception?
Answer:
A stack trace is dumped for the thread with the exception, but other threads will continue to run.

Question 5:
What is the difference between the threading and the thread modules?
Answer:
The threading module was introduced in Python 2.4 and is a higher-level manager of thread processes. Threading is a little more complex to initialize but provides better control.

Question 6:
How are threads synchronized, to prevent race and deadlock conditions?
Answer:
Using the.Lock( ) method of the threading module to create a lock object, then using .acquire( ) and .release( ) on that lock.

Question 7:
What is a timer interrupted thread, and when would it be used?
Answer:
Timer threads are created using the.Timer( ) method of the threading module. They are used for periodic cleanups, status reporting, etc.

Question 8:
Illustrate creating a timer thread that executes every 10 minutes.
Answer:
import threading
myTimer = threading.Timer(600, myFunction)
myTimer.start( )

Question 9:
How is a timer interrupted thread stopped?
Answer:
By using the .cancel( ) method of the timer thread object.

Question 10:
What is the Queue module and when is it used?
Answer:
The Queue module is a device to handle a multithreaded prioritized queue of processing tasks. It is useful when there are a number of incoming requests, with different priorities that need to be allocated processing resources.

Question 11:
How are objects added to a queue?
Answer:
Using the .put( ) method of the queue object.

Question 12:
How are objects retrieved from a queue?
Answer:
Using the .get( ) method of the queue object.

Question 13:
What are some useful methods and properties of the queue?
Answer:
.empty( ), .full( ) and .qsize( ) are useful for determining the state of the queue. .get() and .put() are used to add and remove items from the queue.

Question 14:
When using the .acquire!) method of the threading. Lock object, what does the addition of the blocking parameter do?
Answer:
The blocking parameter prevents return to the calling process until the lock can be acquired. If acquire is called without a parameter, or with 0 or false, it will immediately return with a 0 value if the lock cannot be acquired. If blocking is true, the thread will stop execution until the lock is acquired.

Question 15:
What is the difference between the .start( ) and, run() methods of the new thread object?
Answer:
.start starts the activity of a thread, .run is a method representing the thread’s activity that may be overridden in a subclass.

Question 16:
When is .isAlive( ) true?
Answer:
From when the start method is called until the run method terminates on a particular thread.

Question 17:
How is the .join() method useful for thread synchronization?
Answer:
.join() is used to block the current thread’s execution until the thread the .join is being called on terminates, or a timeout expires, at which time the calling thread’s execution resumes.

Question 18:
How is the current thread retrieved?
Answer:
By calling the .currentThread( ) method of the thread module.

Question 19:
How is the number of threads that are currently running retrieved?
Answer:
Using the threading.activeCount( ) method.

Question 20:
What is a semaphore object?
Answer:
It is a method of synchronizing activity between multiple threads.

Pandas DataFrame iterrows() Function:

Pandas dataframe iterrows: Iterate through the DataFrame rows with the iterrows() function of the Pandas DataFrame, which returns a tuple with the row index and the row data as a Series.

Syntax:

DataFrame.iterrows()

Parameters: This method doesn’t accept any parameters

Return Value:

Gives the following:

index: label or a tuple of label

This is required. The row’s index number. A tuple for a MultiIndex.

data: Series

This is required. It is the data of the row as a Series.

it: generator

This is required. A generator that loops across the rows of the frame.

Pandas DataFrame iterrows() Function in Python

Approach:

Below is the implementation:

Output:

# Import pandas module using the import keyword.
import pandas as pd
# Import NumPy module using the import keyword.
import numpy as np
# Pass some random key-value pair(dictionary), index list as arguments to the 
# DataFrame() function of the pandas module to create a dataframe
# Store it in a variable.
data_frme = pd.DataFrame({
  "emp_name": ["john", "nick" , "jessy", "mary"],
  "emp_age": [25, 35, 38, 22],
  "emp_salary": [25000, 40000, 22000, 80000]},
  index= [1, 2, 3, 4]
)

print("The given DataFrame:")
print(data_frme)
print()

for label, data in data_frme.iterrows():
  print(f'label: {label}')
  print(f'data: \n{data}')
  print()

Require not defined javascript: The “ReferenceError: require is not defined” error can arise for several reasons:

• When we use the require() function in a browser environment.
• When we use the require() function in a Node.js project, where type is set to module in the package.json file.
• When we use the require() function in Node.js, where files have a .mjs extension.

Fixing the ReferenceError require is not defined in JavaScript

Use the ES6 module import and export syntax to resolve the “ReferenceError need is not defined” error.

index.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
  </head>

  <body>
    <!-- Write your HTML elements here  -->

    <!-- adding type as module in the script   -->
    <script type="module" src="index.js"></script>
    <script type="module" src="anotherFile.js"></script>
  </body>
</html>

• Now we can use the ES6 imports/exports syntax in index.js and anotherFile.js.
• The index.js file exports a variable and a function.

index.js:

// Create a default export function say multiply which accepts
// two numbers as arguments and returns their multiplication result
export default function multiply(x, y) {
  // Returns the multiplication result of the passed two numbers
  return x * y;
}

// This is named export
export const id = 50;

Now we import the above index.js file into another file and can be accessed there.

index.js:

// Here we are importing the default and named export from the
// index.js file using the import keyword
import multiply, {id} from './index.js';

// Passing two numbers as arguments to the multiply() function
// (of index.js file) to get the multiplication of two numbers and
// print the result
console.log(multiply(3, 4)); // Output => 12
// Printing the 'id' variable value (of index.js file)
console.log(id); // Output => 50

Output:

12
50

NOTE:

Please keep in mind that each file can only have one default export.
In the browser, use this syntax (ES6 Modules) rather than the 'require()' function.

Alternatively, you can insert the index.js file’s script above the anotherFile.js file’s script, and the function and variables from the index.js file will be made available to anotherFile.js without exporting and importing them.

Here’s an example that doesn’t include any imports or exports.

index.js:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
  </head>

  <body>

    <!--Here the index.js file is loaded first, hence we can use the functions of it in anotherFile.js file-->
    <script src="index.js"></script>
    <script src="another-file.js"></script>
  </body>
</html>

The index.js file just defines a function and a variable.

index.js:

// Create a default export function say multiply which accepts
// two numbers as arguments and returns their multiplication result
export default function multiply(x, y) {
  // Returns the multiplication result of the passed two numbers
  return x * y;
}

// This is named export
export const id = 50;

We can now utilize the function and variable in our other code without even having to import them.

anotherFile.js:

// Passing two numbers as arguments to the multiply() function
// (of index.js file) to get the multiplication of two numbers and
// print the result
console.log(multiply(3, 4)); // Output => 12
// Printing the 'id' variable value (of index.js file)
console.log(id); // Output => 50

Output:

12
50

Fixing the ERROR

If the require() function of the server is not specified/defined, we have set the type attribute/property to module in our package.jsonfile, or all files that have an extension of .mjs instead of .js.

To resolve the “ReferenceError require is not defined” error, remove the type property from your package.json file if it is set to the module and rename any files with file.mjs extension to have file.js extension.

package.json:

{
  // It should be removed if we want to use require
   "type": "module",
   
  // Write the rest of the code.....
}

You may also utilize the ES6 module syntax with the import and export keywords.

Set the type property in your package.json file to module if you wish to utilize the import/export syntax to import and export modules.

package.json:

{
  // Here we must add this below one
  "type": "module",
   // Write the rest of the code.....
}

We must have to replace the require and module.exports syntax with the import and export keywords.

Let us see an example where we define a function and a variable, and then export the function as a default export and the variable as a named export.

index.js:

// Create a function(default export) say multiply which accepts
// two numbers as arguments and returns their multiplication result
export default function multiply(x, y) {
  // Returns the multiplication result of the passed two numbers
  return x * y;
}

// This is named export
export const id = 50;

Now we are importing them into anotherFile.js from the above index.js file

anotherFile.js:

// Here we are importing the default and named import from the
// index.js file using the import keyword
import multiply, {id} from './index.js';

// Passing two numbers as arguments to the multiply() function
// (of index.js file) to get the multiplication of two numbers and
// print the result
console.log(multiply(2, 10)); // Output => 20
// Printing the 'id' variable value (of index.js file)
console.log(id); // Output => 50

Output:

20
50

NOTE:

• As said earlier, please keep in mind that you can only use 1 default export per file.
• You cannot use the require() function in combination with the ES6 Module import/export syntax. You must use one or the other on a consistent basis.

NumPy loadtxt() Function:

Numpy loadtxt: To load data from a text file, use the loadtxt() function of the NumPy module. In a text file, each row of the text file must have the same number of values.

Syntax:

numpy.loadtxt(filename, dtype=<class 'float'>)

Parameters

filename: This is required. The file, filename, or generator to read is specified by this argument. If the filename extension is.gz or.bz2, we’ll start by decompressing the file. After that, the generators will return Python 3k byte strings. It’s important to note that generators should only return byte strings.

dtype: This is optional. The datatype of the output array is indicated by this argument. float is the default value.

Return value

np loadtext: The data read from the text file is returned.

NumPy loadtxt() Function in Python

Example1

Approach:

• Import numpy module using the import keyword
• Pass some random list as an argument to the array() function
  of the Numpy module to create an array.
• Store it in a variable.
• Save the above-given array as a text file with some random filename using the savetxt() function of the Numpy module
• Load the above textfile using the loadtxt() function of the Numpy module
• Print the above file content.
• The Exit of the Program.

Below is the implementation:

# Import numpy module using the import keyword
import numpy as np
# Pass some random list as an argument to the array() function
# of the Numpy module to create an array. 
# Store it in a variable.
gvn_arry = np.array([1, 12, 35, 20, 70])                     

# Save the above given array  as a text file with some random filename
# using the savetxt() function of the Numpy module
np.savetxt("samplefile", gvn_arry)

# Load the above textfile using the loadtxt() function of the Numpy module
file_content = np.loadtxt("samplefile")
print()
# Print the above file content
print("The above file content:")
print(file_content)

Output:

The above file content:
[ 1. 12. 35. 20. 70.]