100 Python questions, one for each day of the challenge:

1 Print the length of the string "Hello, world!".

2 Print the sum of the numbers 1 and 2.

3 Print the Fibonacci sequence up to the 10th term.

4 Check whether a number is prime or not.

5 Find the factorial of a number.

6 Print a multiplication table for a given number.

7 Check whether a string is a palindrome or not.

8 Convert a temperature from Celsius to Fahrenheit.

9 Convert a temperature from Fahrenheit to Celsius.

10 Check whether a year is a leap year or not.

11 Write a function to check whether a string is a pangram or not.

12 Write a function to find the longest common substring of two strings.

13 Write a function to reverse a string.

14 Write a function to check whether a number is a perfect square or not.

15 Write a function to find the greatest common divisor (GCD) of two numbers.

16 Write a function to find the least common multiple (LCM) of two numbers.

17 Write a function to check whether a number is an Armstrong number or not.

18 Write a function to find the kth permutation of a given set of numbers.

19 Write a function to find the next lexicographical permutation of a given string.

20 Write a function to check whether a graph is bipartite or not.

21 Write a function to find the shortest path between two nodes in a graph.

22 Write a function to find the minimum spanning tree of a graph.

23 Write a function to find the diameter of a tree.

24 Write a function to check whether a tree is a binary search tree or not.

25 Write a function to insert a node into a binary search tree.

26 Write a function to delete a node from a binary search tree.

27 Write a function to search for a node in a binary search tree.

28 Write a function to find the inorder successor of a node in a binary search tree.

29 Write a function to find the preorder successor of a node in a binary search tree.

30 Write a function to find the postorder successor of a node in a binary search tree.

31 Write a function to find the level order traversal of a binary tree.

32 Write a function to find the height of a binary tree.

33 Write a function to check whether a binary tree is balanced or not.

34 Write a function to convert an infix expression to a postfix expression.

35 Write a function to convert a postfix expression to an infix expression.

36 Write a function to evaluate a postfix expression.

37 Write a function to find the maximum depth of a nested list.

38 Write a function to flatten a nested list.

39 Write a function to check whether a linked list is a palindrome or not.

40 Write a function to reverse a linked list.

41 Write a function to insert a node into a linked list.

42 Write a function to delete a node from a linked list.

43 Write a function to search for a node in a linked list.

44 Write a function to find the middle node in a linked list.

45 Write a function to find the nth node from the end of a linked list.

46 Write a function to merge two sorted linked lists.

47 Write a function to find the intersection point of two linked lists.

48 Write a function to find the union of two linked lists.

49 Write a function to check whether a linked list is circular or not.

50 Write a function to find the length of a linked list.

51 Write a function to find the median of a list of numbers.

52 Write a function to find the mode of a list of numbers.

53 Write a function to find the range of a list of numbers.

54 Write a function to find the variance of a list of numbers.

55 Write a function to find the standard deviation of a list of numbers.

56 Write a function to find the covariance of two lists of numbers.

57 Write a function to find the correlation coefficient of two lists of numbers.

58 Write a function to fit a linear regression model to a dataset.

59 Write a function to fit a logistic regression model to a dataset.

60 Write a function to perform k-means clustering on a dataset.

61 Write a function to implement the Naive Bayes classification algorithm.

62 Write a function to implement the Support Vector Machine (SVM) classification algorithm.

63 Write a function to implement the Random Forest classification algorithm.

64 Write a function to implement the K-Nearest Neighbors (KNN) classification algorithm.

65 Write a function to implement the Decision Tree classification algorithm.

66 Write a function to implement the Naive Bayes classification algorithm for spam filtering.

67 Write a function to implement the Support Vector Machine (SVM) classification algorithm for sentiment analysis.

68 Write a function to implement the Random Forest classification algorithm for image recognition.

69 Write a function to implement the K-Nearest Neighbors (KNN) classification algorithm for handwriting recognition.

70 Write a function to implement the Decision Tree classification algorithm for medical diagnosis.

71 Define a class to represent a bank account.

72 Define a class to represent a student.

73 Define a class to represent a book.

74 Define a class to represent an employee.

75 Define a class to represent a car.

76 Implement inheritance in a class hierarchy for animals.

77 Implement polymorphism in a class hierarchy for shapes.

78 Implement encapsulation in a class to represent a bank account.

79 Implement abstraction in a class to represent a

80 Implement a stack data structure using Python.

81 Implement a queue data structure using Python.

82 Implement a linked list data structure using

83 Implement a double-linked list data structure using Python.

84 Implement a circular linked list data structure using Python.

85 Implement a binary search tree data structure using Python.

86 Implement an AVL tree data structure using Python.

87 Implement a red-black tree data structure using Python.

88 Implement a hash table data structure using Python.

89 Implement a heap data structure using Python.

90 Implement a graph data structure using Python.

91 Implement a directed graph data structure using Python.

92 Implement a weighted graph data structure using Python.

93 Implement a breadth-first search algorithm for traversing a graph.

94 Implement a depth-first search algorithm for traversing a graph.

95 Implement Dijkstra's algorithm for finding the shortest path in a weighted graph.

96 Implement Kruskal's algorithm for finding the minimum spanning tree of a weighted graph.

97 Implement Prim's algorithm for finding the minimum spanning tree of a weighted graph.

98 Implement a sorting algorithm, such as bubble sort, insertion sort, merge sort, or quick sort.

99 Implement a searching algorithm, such as binary search or linear search.

100 Write a Python program to solve a real-world problem, such as building a simple web scraper, a text summarizer, or a financial data analyzer.

Read More

print ((False == False) in [False]) print (False == (False in [False])) print (False == False in [False])

 Code :

print(False == False) in [False]

print (False == (False in [False]))

print (False == False in [False])

Answer:

False

False

True

Solution and Explanation:

Let's go through each line:

print((False == False) in [False])

False == False is True.

The expression becomes True in [False].

Since True is not in the list [False], the final result is False.

The output for this line is False.

print(False == (False in [False]))

False in [False] is True.

The expression becomes False == True.

The output for this line is False.

print(False == False in [False])

This expression is equivalent to (False == False) and (False in [False]).

Both conditions are True.

The output for this line is True.

Read More

Python Coding challenge - Day 80 | What is the output of the following Python code?

 

Code :

list1 = ["1.0", "a", "0.1", "1", "-1"]

list2 = sorted(list1, key=lambda x: float(x) if x.isdigit() else float('inf'))

print(list2)

Answer : ['1', '1.0', 'a', '0.1', '-1']

Solution and Explanation: 

list1 = ["1.0", "a", "0.1", "1", "-1"]

This line creates a list named list1 and assigns it the values ["1.0", "a", "0.1", "1", "-1"].

list2 = sorted(list1, key=lambda x: float(x) if x.isdigit() else float('inf'))

This line creates a list named list2 and assigns it the sorted values of list1. The key argument specifies that the sorting should be done by converting the elements to floats if they are digits, and otherwise using the value float('inf'). This means that the strings "-1", "a", and "0.1" will be sorted as if they were the numbers -1, inf, and 0.1, respectively.

print(list2)

This line prints the value of list2 to the console.

Here is a table that summarizes the steps involved in sorting the list:

Step Action

1 Create a list named list1 and assign it the values ["1.0", "a", "0.1", "1", "-1"].

2 Create a list named list2 and assign it the sorted values of list1.

3 Sort list2 using the key argument, which specifies that the sorting should be done by converting the elements to floats if they are digits, and otherwise using the value float('inf').

4 Print the value of list2 to the console.

Read More

How many objects are created in the following code snippet?

 How many objects are created in the following code snippet?

a = 10

b = a

c = b

Answer : one 

a is assigned the value 10, creating an integer object with the value 10.

b is assigned the value of a, so it refers to the same integer object as a. No new object is created in this step; it just points to the existing object.

c is assigned the value of b, so it also refers to the same integer object as a and b. Again, no new object is created in this step.

Read More

a = 20 b = 40 print(globals( )) print(locals( ))

 Code :

a = 20

b = 40

print(globals( ))

print(locals( ))

Solution and Explanation: 

The globals() function returns a dictionary representing the current global symbol table, while the locals() function returns a dictionary representing the current local symbol table. When you print these dictionaries in your code, you'll see the global and local variables along with their values.

Here's the modified code:

a = 20

b = 40

print("Global variables:")

print(globals())

print("\nLocal variables:")

print(locals())

When you run this code, you will see the global and local variables along with their values. Keep in mind that the output might vary depending on where you run this code (e.g., in a script or an interactive environment like a Jupyter notebook).

Note: The locals() function inside a function or method will return the local symbol table of that function or method. If you run it in the global scope, it will return the same result as globals().

The output will typically look like this:

Global variables:

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <...>, '__spec__': None, '__annotations__': {}, '__builtins__': <...>, '__file__': 'your_file_path', '__cached__': None, 'a': 20, 'b': 40}

Local variables:

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <...>, '__spec__': None, '__annotations__': {}, '__builtins__': <...>, '__file__': 'your_file_path', '__cached__': None, 'a': 20, 'b': 40}

The dictionaries returned by globals() and locals() contain information about the global and local namespaces, respectively. In this case, the global variables a and b are included in both dictionaries. The keys in the dictionaries include special variables like __name__, __doc__, etc., along with your defined variables.

The output might vary slightly depending on where you run this code and the specific environment you are using.

Read More

Download YouTube videos using Python

 

Code : 

# Download YouTube videos using Python

pip install yt-dlp

import yt_dlp

# Enter the url for the download 

url = input("Enter video url: ")

ydl_opts = {}

with yt_dlp. YoutubeDL (yd1_opts) as ydl: 

      ydl.download ([url])

print("Video downloaded successfully!")

#clcoding.com

Enter video url: https://youtu.be/b1kbLwvqugk

Read More

Python code to find info about Chemical Formula

 

pip install pubchempy

import pubchempy as pcp

# Define the chemical formula of the hydrocarbon

chemical_formula = input("Enter chemical Formula : ")  

try:

    # Search PubChem for the compound by its chemical formula

    compound = pcp.get_compounds(chemical_formula, 'formula')[0]

    # Display information about the compound

    print(f"Name: {compound.iupac_name}")

    print(f"Common Name: {compound.synonyms[0]}")

    print(f"Molecular Weight: {compound.molecular_weight}")

    print(f"Formula: {compound.molecular_formula}")

    # You can access more properties as needed

except IndexError:

    print(f"No information found for {chemical_formula}.Please check formula.")

    #clcoding.com

Read More

Python Coding challenge - Day 79 | What is the output of the following Python code?

 

Code : 

import sys, getopt

sys.argv =['C:\\a.py', '-h', 'word1', 'word2']

options, arguments = getopt.getopt(sys.argv[1:],'s:t:h')

print(options)

Solution and Explanation:

This code outputs the following:

[('-h', '')]

The getopt.getopt() function takes two arguments:

The first argument is the sequence of arguments to be parsed. This is typically sys.argv[1:], which is a list of all the command-line arguments except for the program name.

The second argument is the option string. This is a string of characters, where each character represents an option. If an option requires an argument, the character is followed by a colon. For example, the option string "s:t:h" defines three options:

-s: This option requires an argument, which is stored in the optarg variable.

-t: This option requires an argument, which is stored in the optarg variable.

-h: This option does not require an argument.

The getopt.getopt() function returns a list of two-element tuples. Each tuple consists of an option character and its argument, if any. For example, the tuple ('-h', '') indicates that the -h option was specified without an argument.

In this case, the command-line arguments are ['C:\\a.py', '-h', 'word1', 'word2']. The option string is 's:t:h'. Therefore, the getopt.getopt() function returns the list [('-h', '')], which indicates that the -h option was specified without an argument.

Read More

How will you store a hexadecimal value E0A485 in a bytes data type?

 In Python, you can store a hexadecimal value like E0A485 in a bytes data type using the bytes.fromhex() method. Here's an example:

hex_value = "E0A485"

bytes_data = bytes.fromhex(hex_value)

print(bytes_data)

This code will output a bytes object representing the hexadecimal value:

b'\xe0\xa4\x85'

Each pair of hexadecimal digits is converted to its corresponding byte value in the bytes object. In this example, E0 becomes \xe0, A4 becomes \xa4, and 85 becomes \x85.

Read More

Python 101: 2nd Edition

 

The second edition of Python 101 (50,000+ eBook readers alone) uses Python 3 to teach you how to program successfully. This book can be read by people with no programming experience, although understanding basic computer terminology is recommended.

While Python 101 teaches you all the basics that you need to know, it also dives into many intermediate level topics too. This book is split up into four sections:

The Python Language

Intermediate Topics

Creating Sample Applications

Distributing Your Code

This book has been completely rewritten from the ground up. There are many new chapters and coverage of new features in Python 3.

Another new feature is that Python 101 has Review Questions for every chapter. The book also includes an answer key in the back.

Unlike most beginner Python books, Python 101 explains how to create simple applications. It also goes on to teach you how to distribute your code as a Windows executable.

Amazon Buy : Python 101: 2nd Edition 

Gumroad Buy : Python 101: 2nd Edition

Read More

c = "clcoding" print(c[:-2]) print(c[-2:])

 Code :

c = "clcoding"

print(c[:-2])

print(c[-2:])

Solution and Explanations: 

here are the step-by-step solutions:

Step 1:

Define the variable c and assign the string "clcoding" to it.

c = "clcoding"

Step 2:

Print the substring of c that starts at the beginning of the string and goes up to the second to last character. This can be done using the slicing syntax c[:-2].

print(c[:-2])

Output:

clcodi

Step 3:

Print the substring of c that starts at the second to last character and goes up to the end of the string. This can be done using the slicing syntax c[-2:].

print(c[-2:])

Output:

ng

Read More

State whether the following statements are True or False for Python Dictionaries

 a. Dictionary elements can be accessed using position-based index.

Answer

False

b. Dictionaries are immutable.

Answer

False

c. Insertion order is preserved by a dictionary.

Answer

False

d. The very first key - value pair in a dictionary d can be accessed using the

expression d[0].

Answer

False

e. courses.clear( ) will delete the dictionary object called courses.

Answer

False

f. It is possible to nest dictionaries.

Answer

True

g. It is possible to hold multiple values against a key in a dictionary.

Answer

True

Let's go through each statement one by one:

a. Dictionary elements can be accessed using position-based index.

Answer: False

Explanation: Dictionary elements are accessed using keys, not position-based indices. You use the key to retrieve the associated value.

b. Dictionaries are immutable.

Answer: False

Explanation: Dictionaries are mutable, meaning you can modify their content by adding, removing, or updating key-value pairs.

c. Insertion order is preserved by a dictionary.

Answer: False

Explanation: Prior to Python 3.7, dictionaries did not guarantee order preservation. However, starting from Python 3.7, the insertion order is guaranteed to be preserved.

d. The very first key-value pair in a dictionary d can be accessed using the expression d[0].

Answer: False

Explanation: Dictionary elements are not accessed by numerical indices but by keys. There is no guarantee that the keys are numerical, so attempting to access d[0] would not necessarily give you the first key-value pair.

e. courses.clear() will delete the dictionary object called courses.

Answer: False

Explanation: courses.clear() will remove all items from the dictionary called courses, but the dictionary object itself still exists.

f. It is possible to nest dictionaries.

Answer: True

Explanation: Yes, it is possible to have dictionaries as values within another dictionary, creating nested or hierarchical structures.

g. It is possible to hold multiple values against a key in a dictionary.

Answer: True

Explanation: Yes, a key in a dictionary can have a list, tuple, set, or another dictionary as its associated value, allowing you to store multiple values against a single key.

Read More

Python Coding challenge - Day 78 | What is the output of the following Python code?

 

Code : 

list1 = ["1.0", "a", "0.1", "1", "-1"]

list2 = sorted(list1)

print(list2)

Solution and Explanations 

The sorted function in Python sorts elements lexicographically (in dictionary order), which means strings are sorted based on their Unicode code points. In your example, the list list1 contains a mix of string representations of numbers and letters. When you use sorted(list1), it will sort the elements lexicographically:

list1 = ["1.0", "a", "0.1", "1", "-1"]

list2 = sorted(list1)

print(list2)

The output will be:

['-1', '0.1', '1', '1.0', 'a']

Here's the breakdown:

'-1' comes first because '-' has a lower Unicode code point than '0'.

'0.1' comes next because '0' has a lower code point than '1'.

'1' comes after '0.1'.

'1.0' comes after '1'.

'a' comes last because letters generally have higher Unicode code points than numbers.

If you want to sort the list based on numeric values, you may consider converting the elements to the appropriate numeric types before sorting. For example:

list1 = ["1.0", "a", "0.1", "1", "-1"]

list2 = sorted(list1, key=lambda x: float(x) if x.replace(".", "", 1).isdigit() else x)

print(list2)

This will output:

['-1', '0.1', '1', '1.0', 'a']

Here, the key argument is used to specify a custom sorting key. The lambda function checks if the string can be converted to a float (ignoring the first occurrence of a decimal point), and if so, it converts it to a float for sorting. This way, numeric values are sorted numerically, and non-numeric values are sorted lexicographically.

 Let's go step by step through the process:

Given Lists:

list1 = ["1.0", "a", "0.1", "1", "-1"]

Use sorted Function:

list2 = sorted(list1)

At this point, list2 is created by sorting the elements of list1 lexicographically.

list2 = ['-1', '0.1', '1', '1.0', 'a']

As explained earlier, the sorting is based on Unicode code points, so the order may not be numeric.

Printing the Result:

print(list2)

The output will be:

['-1', '0.1', '1', '1.0', 'a']

This output reflects the lexicographical sorting of the strings.

Custom Sorting for Numeric Values:

If you want to sort based on numeric values, you can use a custom sorting key. Here's how you can do it:

list2 = sorted(list1, key=lambda x: float(x) if x.replace(".", "", 1).isdigit() else x)

This lambda function checks if the string can be converted to a float (ignoring the first occurrence of a decimal point). If it can, it converts it to a float for sorting.

list2 = ['-1', '0.1', '1', '1.0', 'a']

The output is the same as the previous step because all values can be converted to floats, and they are sorted based on their numeric values.

This step-by-step explanation should clarify how the given list is sorted and how you can customize the sorting for numeric values.

Read More

Numerical Python Scientific Computing and Data Science Applications with Numpy, SciPy and Matplotlib (Free PDF)

 

Leverage the numerical and mathematical modules in Python and its standard library as well as popular open source numerical Python packages like NumPy, SciPy, FiPy, matplotlib and more. This fully revised edition, updated with the latest details of each package and changes to Jupyter projects, demonstrates how to numerically compute solutions and mathematically model applications in big data, cloud computing, financial engineering, business management and more.

Numerical Python, Second Edition, presents many brand-new case study examples of applications in data science and statistics using Python, along with extensions to many previous examples. Each of these demonstrates the power of Python for rapid development and exploratory computing due to its simple and high-level syntax and multiple options for data analysis.

After reading this book, readers will be familiar with many computing techniques including array-based and symbolic computing, visualization and numerical file I/O, equation solving, optimization, interpolation and integration, and domain-specific computational problems, such as differential equation solving, data analysis, statistical modeling and machine learning.

What You'll Learn

Work with vectors and matrices using NumPy

Plot and visualize data with Matplotlib

Perform data analysis tasks with Pandas and SciPy

Review statistical modeling and machine learning with statsmodels and scikit-learn

Optimize Python code using Numba and Cython

Who This Book Is For

Developers who want to understand how to use Python and its related ecosystem for numerical computing.

Buy : Numerical Python: Scientific Computing and Data Science Applications with Numpy, SciPy and Matplotlib

PDF Download : Numerical Python: Scientific Computing and Data Science Applications with Numpy, SciPy and Matplotlib

Read More

The Little Book of Deep Learning François Fleuret (Free PDF)

 

Unlock the Power of Deep Learning Embark on an extraordinary journey into the realm of cutting-edge technology with The Little Book of Deep Learning . Discover the secrets behind one of the most revolutionary advancements of our time, and witness how it is transforming industries across the globe. Explore the intricate world of neural networks and artificial intelligence as you delve into the minds of experts and pioneers. Gain unparalleled insights into the principles, algorithms, and applications of deep learning, unraveling complex concepts with ease. From image recognition to natural language processing, uncover the limitless possibilities that await you within these pages. Witness how deep learning is reshaping medicine, finance, entertainment, and more, igniting a new era of innovation. Written by a leading authority in the field, this captivating book distills the essence of deep learning, providing a comprehensive yet accessible guide for both beginners and seasoned professionals. Its engaging narrative and practical examples will empower you to harness the true potential of this transformative technology. Don't miss your chance to join the ranks of those who have unlocked the power of deep learning. Whether you're a student, researcher, or industry enthusiast, The Little Book of Deep Learning is your gateway to a world of unlimited possibilities.

Buy : The Little Book of Deep Learning

PDF Download : The Little Book of Deep Learning Free PDF

Read More

Python® Notes for Professionals book (Free PDF)

 

Getting started with Python Language

1. Python Data Types
2. Indentation
3. Comments and Documentation
4. Date and Time
5. Date Formatting
6. Enum
7. Set
8. Simple Mathematical Operators
9. Bitwise Operators
10. Boolean Operators
11. Operator Precedence
12. Variable Scope and Binding
13. Conditionals
14. Comparisons
15. Loops
16. Arrays
17. Multidimensional arrays
18. Dictionary
19. List
20. List comprehensions
21. List slicing (selecting parts of lists)
22. groupby()
23. Linked lists
24. Linked List Node
25. Filter
26. Heapq
27. Tuple
28. Basic Input and Output
29. Files & Folders I/O
30. os.path
31. Iterables and Iterators
32. Functions
33. Defining functions with list arguments
34. Functional Programming in Python
35. Partial functions
36. Decorators
37. Classes
38. Metaclasses
39. String Formatting
40. String Methods
41. Using loops within functions
42. Importing modules
43. Difference between Module and Package
44. Math Module
45. Complex math
46. Collections module
47. Operator module
48. JSON Module
49. Sqlite3 Module
50. The os Module
51. The locale Module
52. Itertools Module
53. Asyncio Module
54. Random module
55. Functools Module
56. The dis module
57. The base64 Module
58. Queue Module
59. Deque Module
60. Webbrowser Module
61. tkinter
62. pyautogui module
63. Indexing and Slicing
64. Plotting with Matplotlib
65. graph-tool
66. Generators
67. Reduce
68. Map Function
69. Exponentiation
70. Searching
71. Sorting, Minimum and Maximum
72. Counting
73. The Print Function
74. Regular Expressions (Regex)
75. Copying data
76. Context Managers (“with” Statement)
77. The __name__ special variable
78. Checking Path Existence and Permissions
79. Creating Python packages
80. Usage of "pip" module: PyPI Package Manager
81. pip: PyPI Package Manager
82. Parsing Command Line arguments
83. Subprocess Library
84. setup.py
85. Recursion
86. Type Hints
87. Exceptions
88. Raise Custom Errors / Exceptions
89. Commonwealth Exceptions
90. urllib
91. Web scraping with Python
92. HTML Parsing
93. Manipulating XML
94. Python Requests Post
95. Distribution
96. Property Objects
97. Overloading
98. Polymorphism
99. Method Overriding
100. User-Defined Methods
101. String representations of class instances: __str__ and __repr__ methods
102. Debugging
103. Reading and Writing CSV
104. Writing to CSV from String or List
105. Dynamic code execution with `exec` and `eval`
106. PyInstaller - Distributing Python Code
107. Data Visualization with Python
108. The Interpreter (Command Line Console)
109. *args and **kwargs
110. Garbage Collection
111. Pickle data serialisation
112. Binary Data
113. Idioms
114. Data Serialization
115. Multiprocessing
116. Multithreading
117. Processes and Threads
118. Python concurrency
119. Parallel computation
120. Sockets
121. Websockets
122. Sockets And Message Encryption/Decryption Between Client and Server
123. Python Networking
124. Python HTTP Server
125. Flask
126. Introduction to RabbitMQ using AMQPStorm
127. Descriptor
128. tempfile NamedTemporaryFile
129. Input, Subset and Output External Data Files using Pandas
130. Unzipping Files
131. Working with ZIP archives
132. Getting start with GZip
133. Stack
134. Working around the Global Interpreter Lock (GIL)
135. Deployment
136. Logging
137. Web Server Gateway Interface (WSGI)
138. Python Server Sent Events
139. Alternatives to switch statement from other languages
140. List destructuring (aka packing and unpacking)
141. Accessing Python source code and bytecode
142. Mixins
143. Attribute Access
144. ArcPy
145. Abstract Base Classes (abc)
146. Plugin and Extension Classes
147. Immutable datatypes(int, float, str, tuple and frozensets)
148. Incompatibilities moving from Python 2 to Python 3
149. 2to3 tool
150. Non-official Python implementations
151. Abstract syntax tree
152. Unicode and bytes
153. Python Serial Communication (pyserial)
154. Neo4j and Cypher using Py2Neo
155. Basic Curses with Python
156. Templates in python
157. Pillow
158. The pass statement
159. CLI subcommands with precise help output
160. Database Access
161. Connecting Python to SQL Server
162. PostgreSQL
163. Python and Excel
164. Turtle Graphics
165. Python Persistence
166. Design Patterns
167. hashlib
168. Creating a Windows service using Python
169. Mutable vs Immutable (and Hashable) in Python
170. configparser
171. Optical Character Recognition
172. Virtual environments
173. Python Virtual Environment - virtualenv
174. Virtual environment with virtualenvwrapper
175. Create virtual environment with virtualenvwrapper in windows
176. sys
177. ChemPy - python package
178. pygame
179. Pyglet
180. Audio
181. pyaudio
182. shelve
183. IoT Programming with Python and Raspberry PI
184. kivy - Cross-platform Python Framework for NUI Development
185. Pandas Transform: Preform operations on groups and concatenate the results
186. Similarities in syntax, Differences in meaning: Python vs. JavaScript
187. Call Python from C#
188. ctypes
189. Writing extensions
190. Python Lex-Yacc
191. Unit Testing
192. py.test
193. Profiling
194. Python speed of program
195. Performance optimization
196. Security and Cryptography
197. Secure Shell Connection in Python
198. Python Anti-Patterns
199. Common Pitfalls
200. Hidden Features
201. Example book pages

Download : Python® Notes for Professionals book

Read More

Its hard to believe, but the best 6 machine learning books are completely free:

 

- Deep Learning - https://lnkd.in/gxpnZ6Sa

- Dive into Deep Learning - d2l.ai

- Machine Learning Engineering - https://lnkd.in/eVCAYh4

- Python Data Science Handbook - https://lnkd.in/ehfZ-Tx

- Probabilistic Machine Learning - https://lnkd.in/gcSBFgk

- Machine Learning Yearning - https://lnkd.in/d3bC2d2R

Read More

Approaching (Almost) Any Machine Learning Problem (PDF Book)

 

This book is for people who have some theoretical knowledge of machine learning and deep learning and want to dive into applied machine learning. The book doesn't explain the algorithms but is more oriented towards how and what should you use to solve machine learning and deep learning problems. The book is not for you if you are looking for pure basics. The book is for you if you are looking for guidance on approaching machine learning problems. The book is best enjoyed with a cup of coffee and a laptop/workstation where you can code along.

Table of contents:

- Setting up your working environment

- Supervised vs unsupervised learning

- Cross-validation

- Evaluation metrics

- Arranging machine learning projects

- Approaching categorical variables

- Feature engineering

- Feature selection

- Hyperparameter optimization

- Approaching image classification & segmentation

- Approaching text classification/regression

- Approaching ensembling and stacking

- Approaching reproducible code & model serving

There are no sub-headings. Important terms are written in bold.

I will be answering all your queries related to the book and will be making YouTube tutorials to cover what has not been discussed in the book. To ask questions/doubts, please create an issue on github repo: https://github.com/abhishekkrthakur/approachingalmost

Buy Link : Approaching (Almost) Any Machine Learning Problem 

PDF Link : Approaching (Almost) Any Machine Learning Problem

Read More

The Principles of Deep Learning Theory (Free PDF)

 

This textbook establishes a theoretical framework for understanding deep learning models of practical relevance. With an approach that borrows from theoretical physics, Roberts and Yaida provide clear and pedagogical explanations of how realistic deep neural networks actually work. To make results from the theoretical forefront accessible, the authors eschew the subject's traditional emphasis on intimidating formality without sacrificing accuracy. Straightforward and approachable, this volume balances detailed first principle derivations of novel results with insight and intuition for theorists and practitioners alike. This self contained textbook is ideal for students and researchers interested in artificial intelligence with minimal prerequisites of linear algebra, calculus. informal probability theory. it can easily fill a semester long course on deep learning theory. For the first time, the exciting practical advances in modern artificial intelligence capabilities can be matched with a set of effective principles, providing a timeless blueprint for theoretical research in deep learning. 

Book Buy : The Principles of Deep Learning Theory: An Effective Theory Approach to Understanding Neural Networks

Book Main page : https://arxiv.org/abs/2106.10165

PDF Link : https://arxiv.org/pdf/2106.10165.pdf

Read More

10 BOOKS THAT WILL BOOST YOUR PRODUCTIVITY!

 

10 BOOKS THAT WILL BOOST YOUR PRODUCTIVITY!

1. Focus on What Matters: A Collection of Stoic Letters on Living Well https://amzn.to/3RgjAJe

2. How to Finish Everything You Start https://amzn.to/3N1KtOr

3. Do It Today: Overcome Procrastination, Improve Productivity, and Achieve More Meaningful Things https://amzn.to/3uDL9mK

4. Atomic Habits: An Easy and Proven Way to Build Good Habits and Break Bad Ones https://amzn.to/49UM3vy

5. Deep Work: Rules for Focused Success in a Distracted World https://amzn.to/3T0lPSo

6. Attention Span: Finding Focus for a Fulfilling Life https://amzn.to/3uv1Lgx

7. Time Wise https://amzn.to/3QUmphJ

8. Do Epic Shit https://amzn.to/3QZfaFc

9. Do the Hard Things First: How to Win Over Procrastination and Master the Habit of Doing Difficult Work (Bulletproof Mindset Mastery Series https://amzn.to/47Nry1Z

10. Do the Impossible: How to Become Extraordinary and Impact the World at Scale (Becoming Extraordinary, Book 1) https://amzn.to/3Ghgrm7

Read More

Match the following for the each values !!

 

Answer

tpl1 = ('A',) - Tuple

tpl1 = ('A') - String

t = tpl[::-1] - Sorts tuple

('A', 'B', 'C', 'D') - tuple of strings

[(1, 2), (2, 3), (4, 5)] - list of tuples

tpl = tuple(range(2, 5)) - (2, 3, 4)

([1, 2], [3, 4], [5, 6]) - tuple of lists

t = tuple('Ajooba') - tuple of length 6

Explanation: 

tpl1 = ('A',) - This creates a tuple named tpl1 containing a single element 'A'. Note the comma after 'A', which is essential for creating a tuple with a single element.

tpl1 = ('A') - This actually creates a string, not a tuple. To create a tuple with a single element, you need to include a comma: tpl1 = ('A',).

t = tpl[::-1] - This reverses the order of elements in the tuple tpl. The [::-1] slicing notation is used to reverse the sequence.

('A', 'B', 'C', 'D') - This is a tuple of strings with four elements: 'A', 'B', 'C', and 'D'.

[(1, 2), (2, 3), (4, 5)] - This is a list of tuples, where each tuple contains two integers.

tpl = tuple(range(2, 5)) - This creates a tuple named tpl with elements generated using range(2, 5), resulting in the tuple (2, 3, 4).

([1, 2], [3, 4], [5, 6]) - This is a tuple of lists, where each list contains two integers.

t = tuple('Ajooba') - This creates a tuple named t from the characters of the string 'Ajooba'. The resulting tuple has six elements, one for each character.

Read More

Python Programming for Data Analysis (Free PDF)

 

This textbook grew out of notes for the ECE143 Programming for Data Analysis class that the author has been teaching at University of California, San Diego, which is a requirement for both graduate and undergraduate degrees in Machine Learning and Data Science. This book is ideal for readers with some Python programming experience. The book covers key language concepts that must be understood to program effectively, especially for data analysis applications. Certain low-level language features are discussed in detail, especially Python memory management and data structures. Using Python effectively means taking advantage of its vast ecosystem. The book discusses Python package management and how to use third-party modules as well as how to structure your own Python modules.  The section on object-oriented programming explains features of the language that facilitate common programming patterns.

After developing the key Python language features, the book moves on to third-party modules that are foundational for effective data analysis, starting with Numpy. The book develops key Numpy concepts and discusses internal Numpy array data structures and memory usage. Then, the author moves onto Pandas and details its many features for data processing and alignment. Because strong visualizations are important for communicating data analysis, key modules such as Matplotlib are developed in detail, along with web-based options such as Bokeh, Holoviews, Altair, and Plotly.

The text is sprinkled with many tricks-of-the-trade that help avoid common pitfalls. The author explains the internal logic embodied in the Python language so that readers can get into the Python mindset and make better design choices in their codes, which is especially helpful for newcomers to both Python and data analysis. 

To get the most out of this book, open a Python interpreter and type along with the many code samples.

Buy : Python Programming for Data Analysis 

PDF Download : 

Read More

Python Coding challenge - Day 77 | What is the output of the following Python code?

 

Code : 

def fun(a, *args, s='!'):

    print(a, s)

    for i in args:

        print(i, s)

fun(10)

Solution and Explanation: 

Function Definition:

def fun(a, *args, s='!'):

The function fun is defined to take at least one argument a, followed by any number of additional positional arguments (*args), and an optional keyword argument s with a default value of '!'.

Print the First Argument and Suffix:

print(a, s)

This line prints the value of the first argument a followed by the value of the keyword argument s.

Loop through Additional Arguments:

for i in args:

    print(i, s)

This loop iterates through any additional positional arguments provided (if any) and prints each one followed by the value of the keyword argument s.

Function Call:

fun(10)

The function is called with the argument 10. Since no additional positional arguments are provided, only the first print statement is executed.

When you run this code, it will output:

10 !

Read More

What will be the output of the following Python code ?

Code : 

s = [a + b for a in ['They ', 'We '] for b in ['are gone!', 'have come!']]

print(s)

Solution and Explanation :  

This code uses list comprehension to create a list s by concatenating elements from two nested lists. Here's the breakdown:

s = [a + b for a in ['They ', 'We '] for b in ['are gone!', 'have come!']]

Two nested for loops are used in the list comprehension.

The outer loop iterates over elements a in the list ['They ', 'We '].

The inner loop iterates over elements b in the list ['are gone!', 'have come!'].

The expression a + b concatenates the current elements from both loops.

The result is a new list s containing all possible concatenations of elements from the outer and inner loops.

If you print the list s, you will get:

['They are gone!', 'They have come!', 'We are gone!', 'We have come!']

This is because it combines each element from the first list with each element from the second list, resulting in all possible combinations.

Read More

a = set() for n in range(21, 30): if n % 2 == 0: a.add(n) print(a)

 Code : 

a = set()

for n in range(21, 30):

    if n % 2 == 0:

        a.add(n)

print(a)

Solution and Explanation:

Let's break down the code step by step:

Initialize an empty set:

a = set()

A new empty set named a is created.

Loop through a range of numbers (21 to 29):

for n in range(21, 30):

The for loop iterates over the numbers from 21 to 29 (inclusive).

Check if the number is even:

if n % 2 == 0:

The if statement checks if the current number (n) is even by using the modulo operator (%) to check if it's divisible by 2.

Add even numbers to the set:

a.add(n)

If the condition in the if statement is true (meaning n is even), the current even number is added to the set a using the add method.

Print the set after the loop:

print(a)

The print(a) statement is outside the for loop, so it will be executed after the loop has finished. It prints the final contents of the set a.

In summary, when you run this code, it will output the set of even numbers between 21 and 29. In this specific case, the set a will contain the even numbers 22, 24, 26, and 28.

In one line : a = {n for n in range(21, 30) if n % 2 == 0}

Read More

State whether the following statements are True or False in Python

 

a. Tuple comprehension offers a fast and compact way to generate a tuple.

Answer

True

b. List comprehension and dictionary comprehension can be nested.

Answer

True

c. A list being used in a list comprehension cannot be modified when it is

being iterated.

Answer

True

d. Sets being immutable cannot be used in comprehension.

Answer

False

e. Comprehensions can be used to create a list, set or a dictionary.

Answer

True

Read More

Introduction to Artificial Intelligence (AI)

 

What you'll learn

Describe what is AI, its applications, use cases, and how it is transforming our lives

Explain terms like Machine Learning, Deep Learning and Neural Networks 

Describe several issues and ethical concerns surrounding AI

Articulate advice from experts about learning and starting a career in AI 

There are 4 modules in this course

In this course you will learn what Artificial Intelligence (AI) is, explore use cases and applications of AI, understand AI concepts and terms like machine learning, deep learning and neural networks. You will be exposed to various issues and concerns surrounding AI such as ethics and bias, & jobs, and get advice from experts about learning and starting a career in AI.  You will also demonstrate AI in action with a mini project.

This course does not require any programming or computer science expertise and is designed to introduce the basics of AI to anyone whether you have a technical background or not. 

Join Free  - Introduction to Artificial Intelligence (AI)

Read More

a = 10 if a in (30, 40, 50): print('Hello') else: print('Hi')

 Code : 

a = 10

if a in (30, 40, 50):

    print('Hello')

else:

    print('Hi')

Solution and Explanation : 

In this example, the value of a is 10, and it's being checked if it's present in the tuple (30, 40, 50). Since 10 is not in that tuple, the else block will be executed, and 'Hi' will be printed. So, when you run this code, you should see the output: Hi

Let's go through the code step by step:

a = 10

Here, a variable a is assigned the value 10.

if a in (30, 40, 50):

This line checks if the value of a is present in the tuple (30, 40, 50). In this case, since a is 10 and 10 is not in the tuple, the condition is False.

    print('Hello')

Since the condition in the if statement is False, the code inside the if block is skipped, and this line is not executed.

else:

Because the condition in the if statement is False, the code inside the else block will be executed.

    print('Hi')

This line prints 'Hi' to the console because the code is now in the else block.

So, when you run this code, the output will be:

Hi

This is because the value of a (which is 10) is not in the specified tuple (30, 40, 50).

Read More

Process Mining: Data science in Action (Free Course)

 

There are 6 modules in this course

Process mining is the missing link between model-based process analysis and data-oriented analysis techniques. Through concrete data sets and easy to use software the course provides data science knowledge that can be applied directly to analyze and improve processes in a variety of domains.

Data science is the profession of the future, because organizations that are unable to use (big) data in a smart way will not survive. It is not sufficient to focus on data storage and data analysis. The data scientist also needs to relate data to process analysis. Process mining bridges the gap between traditional model-based process analysis (e.g., simulation and other business process management techniques) and data-centric analysis techniques such as machine learning and data mining. Process mining seeks the confrontation between event data (i.e., observed behavior) and process models (hand-made or discovered automatically). This technology has become available only recently, but it can be applied to any type of operational processes (organizations and systems). Example applications include: analyzing treatment processes in hospitals, improving customer service processes in a multinational, understanding the browsing behavior of customers using booking site, analyzing failures of a baggage handling system, and improving the user interface of an X-ray machine. All of these applications have in common that dynamic behavior needs to be related to process models. Hence, we refer to this as "data science in action".

The course explains the key analysis techniques in process mining. Participants will learn various process discovery algorithms. These can be used to automatically learn process models from raw event data. Various other process analysis techniques that use event data will be presented. Moreover, the course will provide easy-to-use software, real-life data sets, and practical skills to directly apply the theory in a variety of application domains.

This course starts with an overview of approaches and technologies that use event data to support decision making and business process (re)design. Then the course focuses on process mining as a bridge between data mining and business process modeling. The course is at an introductory level with various practical assignments.

The course covers the three main types of process mining.

1. The first type of process mining is discovery. A discovery technique takes an event log and produces a process model without using any a-priori information. An example is the Alpha-algorithm that takes an event log and produces a process model (a Petri net) explaining the behavior recorded in the log.

2. The second type of process mining is conformance. Here, an existing process model is compared with an event log of the same process. Conformance checking can be used to check if reality, as recorded in the log, conforms to the model and vice versa.

3. The third type of process mining is enhancement. Here, the idea is to extend or improve an existing process model using information about the actual process recorded in some event log. Whereas conformance checking measures the alignment between model and reality, this third type of process mining aims at changing or extending the a-priori model. An example is the extension of a process model with performance information, e.g., showing bottlenecks. Process mining techniques can be used in an offline, but also online setting. The latter is known as operational support. An example is the detection of non-conformance at the moment the deviation actually takes place. Another example is time prediction for running cases, i.e., given a partially executed case the remaining processing time is estimated based on historic information of similar cases.

Process mining provides not only a bridge between data mining and business process management; it also helps to address the classical divide between "business" and "IT". Evidence-based business process management based on process mining helps to create a common ground for business process improvement and information systems development.

The course uses many examples using real-life event logs to illustrate the concepts and algorithms. After taking this course, one is able to run process mining projects and have a good understanding of the Business Process Intelligence field.

After taking this course you should:

- have a good understanding of Business Process Intelligence techniques (in particular process mining),

- understand the role of Big Data in today’s society,

- be able to relate process mining techniques to other analysis techniques such as simulation, business intelligence, data mining, machine learning, and verification,

- be able to apply basic process discovery techniques to learn a process model from an event log (both manually and using tools),

- be able to apply basic conformance checking techniques to compare event logs and process models (both manually and using tools),

- be able to extend a process model with information extracted from the event log (e.g., show bottlenecks),

- have a good understanding of the data needed to start a process mining project,

- be able to characterize the questions that can be answered based on such event data,

- explain how process mining can also be used for operational support (prediction and recommendation), and

- be able to conduct process mining projects in a structured manner.

Join Free - Process Mining: Data science in Action

Read More

Introduction to Mathematical Thinking (Free Course)

 

There are 9 modules in this course

Learn how to think the way mathematicians do – a powerful cognitive process developed over thousands of years.

Mathematical thinking is not the same as doing mathematics – at least not as mathematics is typically presented in our school system. School math typically focuses on learning procedures to solve highly stereotyped problems. Professional mathematicians think a certain way to solve real problems, problems that can arise from the everyday world, or from science, or from within mathematics itself. The key to success in school math is to learn to think inside-the-box. In contrast, a key feature of mathematical thinking is thinking outside-the-box – a valuable ability in today’s world. This course helps to develop that crucial way of thinking.

Join Free  - Introduction to Mathematical Thinking

Read More

Python Coding challenge - Day 76 | What is the output of the following Python code?

 

Code : 

def f1(a,b=[]):

  b.append(a)

  return b

print (f1(2,[3,4]))

Solution and Explanation: 

Answer : [3, 4, 2]

In the given code, you have a function f1 that takes two parameters a and b, with a default value of an empty list [] for b. The function appends the value of a to the list b and then returns the modified list.

When you call f1(2, [3, 4]), it means you are passing the value 2 for a and the list [3, 4] for b. The function then appends 2 to the provided list, and the modified list [3, 4, 2] is returned.

However, it's important to note that when you use a mutable default argument like a list (b=[]), it can lead to unexpected behavior. The default value is created only once when the function is defined, not each time the function is called. So, if you modify the default list (e.g., by appending elements to it), the changes persist across multiple function calls.

If you were to call the function again without providing a value for b, it would continue to use the modified list from the previous call. Here's an example:

print(f1(3))  # Output: [3]

The default value for b is now [3] because of the previous call.

To avoid this issue, it's generally recommended to use None as the default value and create a new list inside the function if needed. Here's an updated version of your function:

def f1(a, b=None):

    if b is None:

        b = []

    b.append(a)

    return b

print(f1(2, [3, 4]))

print(f1(3))

This way, you ensure that a new list is created for each call when a value for b is not provided.

Read More

Dive into Deep Learning (Free PDF)

 

Deep learning has revolutionized pattern recognition, introducing tools that power a wide range of technologies in such diverse fields as computer vision, natural language processing, and automatic speech recognition. Applying deep learning requires you to simultaneously understand how to cast a problem, the basic mathematics of modeling, the algorithms for fitting your models to data, and the engineering techniques to implement it all. This book is a comprehensive resource that makes deep learning approachable, while still providing sufficient technical depth to enable engineers, scientists, and students to use deep learning in their own work. No previous background in machine learning or deep learning is required―every concept is explained from scratch and the appendix provides a refresher on the mathematics needed. Runnable code is featured throughout, allowing you to develop your own intuition by putting key ideas into practice.

Buy : Dive into Deep Learning

PDF Download : Dive into Deep Learning (Free PDF)

Read More

Mathematics for Machine Learning Specialization

 

Specialization - 3 course series

For a lot of higher level courses in Machine Learning and Data Science, you find you need to freshen up on the basics in mathematics - stuff you may have studied before in school or university, but which was taught in another context, or not very intuitively, such that you struggle to relate it to how it’s used in Computer Science. This specialization aims to bridge that gap, getting you up to speed in the underlying mathematics, building an intuitive understanding, and relating it to Machine Learning and Data Science.

In the first course on Linear Algebra we look at what linear algebra is and how it relates to data. Then we look through what vectors and matrices are and how to work with them.

The second course, Multivariate Calculus, builds on this to look at how to optimize fitting functions to get good fits to data. It starts from introductory calculus and then uses the matrices and vectors from the first course to look at data fitting.

The third course, Dimensionality Reduction with Principal Component Analysis, uses the mathematics from the first two courses to compress high-dimensional data. This course is of intermediate difficulty and will require Python and numpy knowledge.

At the end of this specialization you will have gained the prerequisite mathematical knowledge to continue your journey and take more advanced courses in machine learning.

Applied Learning Project

Through the assignments of this specialisation you will use the skills you have learned to produce mini-projects with Python on interactive notebooks, an easy to learn tool which will help you apply the knowledge to real world problems. For example, using linear algebra in order to calculate the page rank of a small simulated internet, applying multivariate calculus in order to train your own neural network, performing a non-linear least squares regression to fit a model to a data set, and using principal component analysis to determine the features of the MNIST digits data set.

Join Free : Mathematics for Machine Learning Specialization

Read More

Mathematics for Machine Learning (Free PDF)

 

The fundamental mathematical tools needed to understand machine learning include linear algebra, analytic geometry, matrix decompositions, vector calculus, optimization, probability and statistics. These topics are traditionally taught in disparate courses, making it hard for data science or computer science students, or professionals, to efficiently learn the mathematics. This self contained textbook bridges the gap between mathematical and machine learning texts, introducing the mathematical concepts with a minimum of prerequisites. It uses these concepts to derive four central machine learning methods: linear regression, principal component analysis, Gaussian mixture models and support vector machines. For students and others with a mathematical background, these derivations provide a starting point to machine learning texts. For those learning the mathematics for the first time, the methods help build intuition and practical experience with applying mathematical concepts. Every chapter includes worked examples and exercises to test understanding. Programming tutorials are offered on the book's web site.

Buy : Mathematics for Machine Learning

PDF Downloads: Mathematics for Machine Learning

Read More

Probabilistic Machine Learning: An Introduction (Adaptive Computation and Machine Learning series) (Free PDF)

 

A detailed and up-to-date introduction to machine learning, presented through the unifying lens of probabilistic modeling and Bayesian decision theory.

This book offers a detailed and up-to-date introduction to machine learning (including deep learning) through the unifying lens of probabilistic modeling and Bayesian decision theory. The book covers mathematical background (including linear algebra and optimization), basic supervised learning (including linear and logistic regression and deep neural networks), as well as more advanced topics (including transfer learning and unsupervised learning). End-of-chapter exercises allow students to apply what they have learned, and an appendix covers notation.

Probabilistic Machine Learning grew out of the author’s 2012 book, Machine Learning: A Probabilistic Perspective. More than just a simple update, this is a completely new book that reflects the dramatic developments in the field since 2012, most notably deep learning. In addition, the new book is accompanied by online Python code, using libraries such as scikit-learn, JAX, PyTorch, and Tensorflow, which can be used to reproduce nearly all the figures; this code can be run inside a web browser using cloud-based notebooks, and provides a practical complement to the theoretical topics discussed in the book. This introductory text will be followed by a sequel that covers more advanced topics, taking the same probabilistic approach.

Buy : Probabilistic Machine Learning: An Introduction (Adaptive Computation and Machine Learning series)

Download : Probabilistic Machine Learning: An Introduction (Adaptive Computation and Machine Learning series)

Read More

Foundations of Data Science (Free PDF)

This book provides an introduction to the mathematical and algorithmic foundations of data science, including machine learning, high-dimensional geometry, and analysis of large networks. Topics include the counterintuitive nature of data in high dimensions, important linear algebraic techniques such as singular value decomposition, the theory of random walks and Markov chains, the fundamentals of and important algorithms for machine learning, algorithms and analysis for clustering, probabilistic models for large networks, representation learning including topic modelling and non-negative matrix factorization, wavelets and compressed sensing. Important probabilistic techniques are developed including the law of large numbers, tail inequalities, analysis of random projections, generalization guarantees in machine learning, and moment methods for analysis of phase transitions in large random graphs. Additionally, important structural and complexity measures are discussed such as matrix norms and VC-dimension. This book is suitable for both undergraduate and graduate courses in the design and analysis of algorithms for data.

Buy : Foundations of Data Science

Download: Foundations of Data Science

Book Description

Covers mathematical and algorithmic foundations of data science: machine learning, high-dimensional geometry, and analysis of large networks.

About the Author

Avrim Blum is Chief Academic Officer at Toyota Technical Institute at Chicago and formerly Professor at Carnegie Mellon University, Pennsylvania. He has over 25,000 citations for his work in algorithms and machine learning. He has received the AI Journal Classic Paper Award, ICML/COLT 10-Year Best Paper Award, Sloan Fellowship, NSF NYI award, and Herb Simon Teaching Award, and is a Fellow of the Association for Computing Machinery (ACM).

John Hopcroft is a member of the National Academy of Sciences and National Academy of Engineering, and a foreign member of the Chinese Academy of Sciences. He received the Turing Award in 1986, was appointed to the National Science Board in 1992 by President George H. W. Bush, and was presented with the Friendship Award by Premier Li Keqiang for his work in China.

Ravi Kannan is Principal Researcher for Microsoft Research, India. He was the recipient of the Fulkerson Prize in Discrete Mathematics (1991) and the Knuth Prize (ACM) in 2011. He is a distinguished alumnus of the Indian Institute of Technology, Bombay, and his past faculty appointments include Massachusetts Institute of Technology, Carnegie Mellon University, Pennsylvania, Yale University, Connecticut, and the Indian Institute of Science.

Read More

a = 10 if a = 30 or 40 or 60 : print('Hello') else : print('Hi')

Code :

a = 10

if a = 30 or 40 or 60 :

print('Hello')

else :

print('Hi')

Solution and Explanation:

Answer : Error

The equality comparison should use == instead of =. Second, you need to compare the variable a against each value separately. Here's the corrected version:

a = 10

if a == 30 or a == 40 or a == 60:

    print('Hello')

else:

    print('Hi')

This way, it checks if a is equal to any of the specified values (30, 40, or 60) and prints 'Hello' if true, otherwise, it prints 'Hi'.

Read More

Improving your statistical inferences (Free Course)

 

There are 8 modules in this course

This course aims to help you to draw better statistical inferences from empirical research. First, we will discuss how to correctly interpret p-values, effect sizes, confidence intervals, Bayes Factors, and likelihood ratios, and how these statistics answer different questions you might be interested in. Then, you will learn how to design experiments where the false positive rate is controlled, and how to decide upon the sample size for your study, for example in order to achieve high statistical power. Subsequently, you will learn how to interpret evidence in the scientific literature given widespread publication bias, for example by learning about p-curve analysis. Finally, we will talk about how to do philosophy of science, theory construction, and cumulative science, including how to perform replication studies, why and how to pre-register your experiment, and how to share your results following Open Science principles. 

In practical, hands on assignments, you will learn how to simulate t-tests to learn which p-values you can expect, calculate likelihood ratio's and get an introduction the binomial Bayesian statistics, and learn about the positive predictive value which expresses the probability published research findings are true. We will experience the problems with optional stopping and learn how to prevent these problems by using sequential analyses. You will calculate effect sizes, see how confidence intervals work through simulations, and practice doing a-priori power analyses. Finally, you will learn how to examine whether the null hypothesis is true using equivalence testing and Bayesian statistics, and how to pre-register a study, and share your data on the Open Science Framework.

Join Free - Improving your statistical inferences

Read More

What will be the output of the following code snippet? num1 = num2 = (10, 20, 30, 40, 50) print(id(num1), type(num2)) print(isinstance(num1, tuple)) print(num1 is num2) print(num1 is not num2) print(20 in num1) print(30 not in num2)

What will be the output of the following code snippet?

num1 = num2 = (10, 20, 30, 40, 50)

1. print(id(num1), type(num2))
2. print(isinstance(num1, tuple))
3. print(num1 is num2)
4. print(num1 is not num2)
5. print(20 in num1)
6. print(30 not in num2)

Solution and Explanation: 

num1 and num2 are both assigned the same tuple (10, 20, 30, 40, 50).

1. print(id(num1), type(num2)) prints the identity and type of num1. Since num1 and num2 reference the same tuple, they will have the same identity. The output will show the identity and type of the tuple.
2. print(isinstance(num1, tuple)) checks if num1 is an instance of the tuple class and prints True because num1 is a tuple.
3. print(num1 is num2) checks if num1 and num2 refer to the same object. Since they are both assigned the same tuple, this will print True.
4. print(num1 is not num2) checks if num1 and num2 do not refer to the same object. Since they are the same tuple, this will print False.
5. print(20 in num1) checks if the value 20 is present in the tuple num1. It will print True.
6. print(30 not in num2) checks if the value 30 is not present in the tuple num2. It will print False.

The output of the code will look something like this:

(id_of_tuple, <class 'tuple'>)

True

True

False

True

False

Read More

num1 = [10, 20] num2 = [30] num1.append(num2) print(num1)

Code - 

num1 = [10, 20]

num2 = [30]

num1.append(num2)

print(num1)

Solution and Explanation :

The above code appends the list num2 as a single element to the list num1. So, num1 becomes a nested list. Here's the breakdown of the code:

num1 = [10, 20]

num2 = [30]

num1.append(num2)

print(num1)

num1 is initially [10, 20].

num2 is [30].

num1.append(num2) appends num2 as a single element to num1, resulting in num1 becoming [10, 20, [30]].

print(num1) prints the updated num1.

The output of the code will be: [10, 20, [30]]

Read More