- -```python -def linear_search(arr, target): - for i in range(len(arr)): - if arr[i] == target: - return i - return -1 -``` - -## Binary Search - -Binary search is an efficient algorithm used for searching in sorted collections. It works by repeatedly dividing the search space in half until the target element is found or the search space is empty. - -```python -def binary_search(arr, target): - low = 0 - high = len(arr) - 1 - while low <= high: - mid = (low + high) // 2 - if arr[mid] == target: - return mid - elif arr[mid] < target: - low = mid + 1 - else: - high = mid - 1 - return -1 -``` - -## Hash-based Search - -Hash-based search utilizes a hash function to map keys to values in a data structure called a hash table. It provides constant-time average case complexity for searching. - -```python -hash_map = { - "apple": 1, - "banana": 2, - "orange": 3 -} - -value = hash_map.get("banana", -1) -print("Value:", value) -``` - -These are just a few examples of searching algorithms and their implementations in different programming languages. The choice of algorithm depends on factors such as the size of the data, whether it is sorted or unsorted, and the desired time complexity. - -Remember to provide appropriate input and handle edge cases when implementing these algorithms to ensure correct results. - -## Additional Questions - -1. **Question:** Implement a linear search algorithm in C++ to find the index of a target element in an array. Provide the input and output for the following scenario: - - **Input:** Array: [5, 2, 9, 7, 3], Target: 9 - - **Output:** Index: 2 - -```cpp -#include
-
- )
-}
-```
-
-## Explanation
-
-In the above example, we have an array of numbers `[64, 34, 25, 12, 22, 11, 90]`. We are using the bubble sort algorithm to sort the array in ascending order. The bubble sort algorithm compares each pair of adjacent items and swaps them if they are in the wrong order. The algorithm repeats this process until the array is sorted. The sorted array is `[11, 12, 22, 25, 34, 64, 90]`. The time complexity of the bubble sort is O(n2) and the space complexity is O(1).
-
-:::info Try it yourself
-Change the array values and see how the bubble sort algorithm sorts the array.
-:::
-
-:::tip 📝 Note
-Bubble sort is not a practical sorting algorithm when the input is large. It is not suitable for large datasets due to its O(n2) time complexity.
-
-The main advantage of bubble sort is that it is easy to understand and implement. It is often used to teach the concept of sorting algorithms.
-
-Bubble sort is stable, meaning that it preserves the relative order of equal elements.
-
-Bubble sort is not an efficient algorithm for large datasets and is generally not used in practice.
-
-:::
-
-## References
-
-- [Wikipedia](https://en.wikipedia.org/wiki/Bubble_sort)
-- [GeeksforGeeks](https://www.geeksforgeeks.org/bubble-sort/)
-- [Programiz](https://www.programiz.com/dsa/bubble-sort)
-- [TutorialsPoint](https://www.tutorialspoint.com/data_structures_algorithms/bubble_sort_algorithm.htm)
-- [StudyTonight](https://www.studytonight.com/data-structures/bubble-sort)
-- [w3schools](https://www.w3schools.com/dsa/dsa_algo_bubblesort.php)
-
-## Related
-
-Insertion Sort, Selection Sort, Merge Sort, Quick Sort, etc.
-
-
-## Quiz
-
-1. What is the time complexity of the bubble sort algorithm?
- - [ ] O(n)
- - [x] O(n2) ✔
- - [ ] O(log n)
- - [ ] O(n!)
-
-2. Is bubble sort a stable sorting algorithm?
- - [x] Yes ✔
- - [ ] No
- - [ ] Maybe
- - [ ] Not sure
-
-3. What is the space complexity of the bubble sort algorithm?
- - [ ] O(n)
- - [x] O(1) ✔
- - [ ] O(log n)
- - [ ] O(n!)
-
-4. What is the main advantage of bubble sort?
- - [ ] It is the fastest sorting algorithm
- - [x] It is easy to understand and implement ✔
- - [ ] It is suitable for large datasets
- - [ ] It is used in practice
-
-5. What is the main disadvantage of bubble sort?
- - [ ] It is the fastest sorting algorithm
- - [ ] It is easy to understand and implement
- - [x] It is not suitable for large datasets ✔
- - [ ] It is used in practice
-
-## Conclusion
-
-In this tutorial, we learned about the bubble sort algorithm. We discussed the algorithm, pseudocode, diagram, example, complexity, and related concepts. We also implemented the bubble sort algorithm in JavaScript and saw a live example. We also discussed the advantages and disadvantages of the bubble sort algorithm. We hope you enjoyed this tutorial and found it helpful. Feel free to share your thoughts in the comments below.
\ No newline at end of file
diff --git a/docs/dsa/arrays/arrays-dsa.md b/docs/dsa/arrays/arrays-dsa.md
deleted file mode 100644
index ce8da614f..000000000
--- a/docs/dsa/arrays/arrays-dsa.md
+++ /dev/null
@@ -1,584 +0,0 @@
----
-id: arrays-in-dsa
-title: Arrays in Data Structures and Algorithms
-sidebar_label: Arrays
-sidebar_position: 1
-description: "An array is a collection of items stored at contiguous memory locations. It is a data structure that stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type."
-tags: [dsa, data-structures, arrays, array, array-data-structure, array-in-dsa, array-in-data-structure, array-in-algorithm, array-in-dsa-example, array-in-dsa-explanation, array-in-dsa-conclusion, array-in-dsa-importance, array-in-dsa-syntax, array-in-dsa-declaration, array-in-dsa-access, array-in-dsa-update, array-in-dsa-length, array-in-dsa-iterate, array-in-dsa-max-min, array-in-dsa-program, array-in-dsa-code, array-in-dsa-js, array-in-dsa-java, array-in-dsa-python, array-in-dsa-c, array-in-dsa-cpp, array-in-dsa-ts]
----
-
-An array is a collection of items stored at contiguous memory locations. It is a data structure that stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
-
-## Visualizations of Arrays in Data Structures and Algorithms (DSA)
-
-Bubble Sort
-Array: [64, 34, 25, 12, 22, 11, 90]
-- Sorted Array: [{arr.join(", ")}] -
-- -The insertion sort algorithm takes value at a time from the unsorted part and places it in its correct position in the sorted part. The sorted part is built from left to right, and the unsorted part is on the right side of the array. The algorithm works by shifting the elements in the sorted part that are greater than the current element to the right, creating space for the current element to be inserted. - -:::info Key Points -- **Type:** Sorting Algorithm -- **Time Complexity:** - - **Best Case:** *O(n)* - - **Average Case:** *O(n2)* - - **Worst Case:** *O(n2)* -- **Space Complexity:** *O(1)* -- **Stable:** Yes -- **In-Place:** Yes -- **Online:** Yes -- **Adaptive:** Yes -- **Comparison Sort:** Yes -- **Suitable for:** Small data sets, partially sorted data sets -- **Efficient for:** Small data sets -- **Not efficient for:** Large data sets -- **Simple to code:** Yes -- **Efficient in practice:** Yes - -::: - -:::tip Real-World Analogy -Insertion sort can be compared to sorting a deck of cards. You start with an empty hand and pick one card at a time from the deck. You then insert the card into its correct position in your hand, shifting the other cards if necessary. This process is repeated until all the cards are sorted in your hand. - -## How Insertion Sort Works? - -Let's understand how the Insertion Sort algorithm works with an example: - -Consider an array `arr = [12, 11, 13, 5, 6]` that we want to sort in ascending order using the Insertion Sort algorithm. - -1. **Initial Array:** `[12, 11, 13, 5, 6]` -2. **Step 1:** Start from the second element (index 1) and compare it with the previous element. - - Compare `11` with `12`. Since `11` is smaller, swap them. - - **Array after Step 1:** `[11, 12, 13, 5, 6]` - - The array is partially sorted from index 0 to 1. - - The current array looks like this: `[11, 12, 13, 5, 6]` - - The sorted part is `[11, 12]`, and the unsorted part is `[13, 5, 6]`. - - The key element is `13`. - - The key element is compared with the elements in the sorted part. - - Since `13` is greater than `12`, no swap is needed. - - The array remains the same: `[11, 12, 13, 5, 6]` - - The array is partially sorted from index 0 to 2. - - The current array looks like this: `[11, 12, 13, 5, 6]` - - The sorted part is `[11, 12, 13]`, and the unsorted part is `[5, 6]`. - - The key element is `5`. - - The key element is compared with the elements in the sorted part. - - Since `5` is smaller than `13`, `12`, and `11`, it is moved to the left. - - **Array after Step 1:** `[5, 11, 12, 13, 6]` - - The array is partially sorted from index 0 to 3. - - The current array looks like this: `[5, 11, 12, 13, 6]` - - The sorted part is `[5, 11, 12, 13]`, and the unsorted part is `[6]`. - - The key element is `6`. - - The key element is compared with the elements in the sorted part. - - Since `6` is smaller than `13`, it is moved to the left. - - Since `6` is smaller than `12`, it is moved to the left. - - Since `6` is smaller than `11`, it is moved to the left. - - **Array after Step 1:** `[5, 6, 11, 12, 13]` - - The array is now sorted. - - The sorted array is `[5, 6, 11, 12, 13]`. - -3. **Final Sorted Array:** `[5, 6, 11, 12, 13]` -4. The array is now sorted in ascending order using the Insertion Sort algorithm. -5. The time complexity of the Insertion Sort algorithm is ***O(n2)*** in the worst-case scenario. -6. The space complexity of the Insertion Sort algorithm is ***O(1)***. -7. The Insertion Sort algorithm is efficient for small data sets and partially sorted data sets. - -## Visualization - -You can visualize the Insertion Sort algorithm using the following animation: - -
-
-
-You can select the Insertion Sort algorithm from the drop-down menu and visualize how it works on different arrays.
-
-:::
-
-## Algorithm
-
-The insertion sort algorithm works as follows:
-
-1. Start from the second element (index 1) and compare it with the previous elements.
-2. If the current element is smaller than the previous element, swap them.
-3. Repeat this process until the current element is greater than the previous element or until the first element is reached.
-4. Move to the next element and repeat the process.
-5. Continue this process until the entire array is sorted.
-6. The array is now sorted.
-7. The time complexity of the insertion sort algorithm is ***O(n2)*** in the worst-case scenario.
-8. The space complexity of the insertion sort algorithm is ***O(1)***.
-
-## Pseudocode
-
-```plaintext
-1. for i = 1 to n-1
-2. key = arr[i]
-3. j = i - 1
-4. while j >= 0 and arr[j] > key
-5. arr[j + 1] = arr[j]
-6. j = j - 1
-7. arr[j + 1] = key
-```
-
-## Implementation
-
-Here's the implementation of the Insertion Sort algorithm in JavaScript:
-
-```javascript title="Insertion Sort"
-function insertionSort(arr) {
- const n = arr.length;
- for (let i = 1; i < n; i++) {
- let key = arr[i];
- let j = i - 1;
- while (j >= 0 && arr[j] > key) {
- arr[j + 1] = arr[j];
- j = j - 1;
- }
- arr[j + 1] = key;
- }
- return arr;
-}
-
-const arr = [12, 11, 13, 5, 6];
-console.log(insertionSort(arr)); // Output: [5, 6, 11, 12, 13]
-```
-
-## Complexity Analysis
-
-The time complexity of the Insertion Sort algorithm is ***O(n2)*** in the worst-case scenario when the array is sorted in reverse order. The best-case time complexity is ***O(n)*** when the array is already sorted.
-
-The space complexity of the Insertion Sort algorithm is ***O(1)*** since it requires only a constant amount of additional memory space.
-
-## References
-
-- [Wikipedia - Insertion Sort](https://en.wikipedia.org/wiki/Insertion_sort)
-- [GeeksforGeeks - Insertion Sort](https://www.geeksforgeeks.org/insertion-sort/)
-- [Programiz - Insertion Sort](https://www.programiz.com/dsa/insertion-sort)
-- [Khan Academy - Insertion Sort](https://www.khanacademy.org/computing/computer-science/algorithms/insertion-sort/a/insertion-sort)
-- [TutorialsPoint - Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/insertion_sort_algorithm.htm)
-- [StudyTonight - Insertion Sort](https://www.studytonight.com/data-structures/insertion-sorting)
-- [Insertion Sort Visualization](https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html)
\ No newline at end of file
diff --git a/docs/dsa/arrays/arrays-selectionsort.md b/docs/dsa/arrays/arrays-selectionsort.md
deleted file mode 100644
index 706040c34..000000000
--- a/docs/dsa/arrays/arrays-selectionsort.md
+++ /dev/null
@@ -1,152 +0,0 @@
----
-id: arrays-selectionsort-in-dsa
-title: Arrays - Selection Sort in DSA
-sidebar_label: Selection Sort
-sidebar_position: 3
-description: "Selection Sort is an in-place comparison sorting algorithm that divides the input list into two parts: the sublist of items already sorted and the sublist of items remaining to be sorted. It repeatedly finds the minimum element from the unsorted part and puts it at the beginning of the unsorted part. The algorithm maintains two subarrays in a given array. The subarray which is already sorted and the remaining subarray which is unsorted. In every iteration of selection sort, the minimum element from the unsorted subarray is picked and moved to the sorted subarray."
-tags: [dsa, arrays, sorting, selection-sort, algorithm of selection-sort, pseudocode of selection-sort, complexity of selection-sort, example of selection-sort, live example of selection-sort, explanation of selection-sort, quiz of selection-sort, conclusion of selection-sort]
----
-
-**Selection Sort** is an in-place comparison sorting algorithm that divides the input list into two parts: the sublist of items already sorted and the sublist of items remaining to be sorted. It repeatedly finds the minimum element from the unsorted part and puts it at the beginning of the unsorted part. The algorithm maintains two subarrays in a given array. The subarray which is already sorted and the remaining subarray which is unsorted. In every iteration of selection sort, the minimum element from the unsorted subarray is picked and moved to the sorted subarray.
-
-
-
- )
-}
-```
-
-In the above example, we have an array of numbers `[64, 25, 12, 22, 11]`. We are using the selection sort algorithm to sort the array in ascending order. The selection sort algorithm divides the input list into two parts: the sublist of items already sorted and the sublist of items remaining to be sorted. It repeatedly finds the minimum element from the unsorted part and puts it at the beginning of the unsorted part. The algorithm maintains two subarrays in a given array. The subarray which is already sorted and the remaining subarray which is unsorted. In every iteration of selection sort, the minimum element from the unsorted subarray is picked and moved to the sorted subarray. The sorted array is `[11, 12, 22, 25, 64]`. The time complexity of the selection sort is O(n^2) and the space complexity is O(1).
-
-:::
-
-## Conclusion
-
-In this article, we learned about the selection sort algorithm. Selection sort is an in-place comparison sorting algorithm that divides the input list into two parts: the sublist of items already sorted and the sublist of items remaining to be sorted. It repeatedly finds the minimum element from the unsorted part and puts it at the beginning of the unsorted part. The algorithm maintains two subarrays in a given array. The subarray which is already sorted and the remaining subarray which is unsorted. In every iteration of selection sort, the minimum element from the unsorted subarray is picked and moved to the sorted subarray. The time complexity of the selection sort is O(n^2) and the space complexity is O(1). Selection sort is a stable sorting algorithm.
\ No newline at end of file
diff --git a/docs/dsa/arrays/bucket-sort.md b/docs/dsa/arrays/bucket-sort.md
deleted file mode 100644
index 8067ac6d2..000000000
--- a/docs/dsa/arrays/bucket-sort.md
+++ /dev/null
@@ -1,204 +0,0 @@
----
-id: bucket-sort
-title: Bucket sort
-sidebar_label: Bucket sort
-tags:
- - DSA
- - Python
- - C++
- - Java
- - Sorting
-
-description: "Thsi page containes Bucket Sort, with codes in python, java and c++ "
----
-
-### Introduction to Bucket Sort
-
-Bucket sort is a comparison sorting algorithm that distributes elements into a number of "buckets." Each bucket is then sorted individually, either using another sorting algorithm or recursively applying the bucket sort. Finally, the sorted buckets are combined to form the final sorted array. Bucket sort is particularly useful for uniformly distributed data.
-
-### Steps of Bucket Sort
-
-1. **Create Buckets**: Initialize an empty array of buckets.
-2. **Distribute Elements**: Distribute the elements of the input array into the appropriate buckets.
-3. **Sort Buckets**: Sort each bucket individually.
-4. **Concatenate Buckets**: Concatenate all sorted buckets to form the final sorted array.
-
-### Pseudocode
-
-```text
-function bucketSort(array, bucketSize):
- if length(array) == 0:
- return array
-
- // Determine minimum and maximum values
- minValue = min(array)
- maxValue = max(array)
-
- // Initialize buckets
- bucketCount = floor((maxValue - minValue) / bucketSize) + 1
- buckets = array of empty lists of size bucketCount
-
- // Distribute input array values into buckets
- for i from 0 to length(array) - 1:
- bucketIndex = floor((array[i] - minValue) / bucketSize)
- append array[i] to buckets[bucketIndex]
-
- // Sort each bucket and concatenate them
- sortedArray = []
- for i from 0 to bucketCount - 1:
- sort(buckets[i]) // You can use any sorting algorithm
- append buckets[i] to sortedArray
-
- return sortedArray
-```
-
-### Implementation in Python, C++, and Java
-
-#### Python Implementation
-
-```python
-def bucket_sort(numbers, size=5):
- if len(numbers) == 0:
- return numbers
-
- # Determine minimum and maximum values
- min_value = min(numbers)
- max_value = max(numbers)
-
- # Initialize buckets
- bucket_count = (max_value - min_value) // size + 1
- buckets = [[] for _ in range(bucket_count)]
-
- # Distribute input array values into buckets
- for number in numbers:
- bucket_index = (number - min_value) // size
- buckets[bucket_index].append(number)
-
- # Sort each bucket and concatenate them
- sorted_numbers = []
- for bucket in buckets:
- sorted_numbers.extend(sorted(bucket))
-
- return sorted_numbers
-
-# Example usage
-data = [42, 32, 33, 52, 37, 47, 51]
-sorted_data = bucket_sort(data)
-print(sorted_data) # Output: [32, 33, 37, 42, 47, 51, 52]
-```
-
-#### C++ Implementation
-
-```cpp
-#include Selection Sort
-Array: [64, 25, 12, 22, 11]
-- Sorted Array: [{arr.join(", ")}] -
-
-
- );
-}
-```
diff --git a/docs/dsa/recursion/_category_.json b/docs/dsa/recursion/_category_.json
deleted file mode 100644
index 1af68bcf8..000000000
--- a/docs/dsa/recursion/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "Recursion",
- "position": 10,
- "link": {
- "type": "generated-index",
- "description": "In data structures, The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. Using a recursive algorithm, certain problems can be solved quite easily. "
- }
-}
diff --git a/docs/dsa/recursion/recursion.md b/docs/dsa/recursion/recursion.md
deleted file mode 100644
index ff8563344..000000000
--- a/docs/dsa/recursion/recursion.md
+++ /dev/null
@@ -1,249 +0,0 @@
----
-id: recursion-in-dsa
-title: Recursion in Data Structures and Algorithms
-sidebar_label: Recursion
-sidebar_position: 3
-description: "Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. It is used in various applications such as solving mathematical problems, implementing data structures, and more."
-tags:
- [
- dsa,
- algorithms,
- recursion,
- recursive-functions,
- recursion-in-dsa,
- recursion-in-algorithm,
- recursion-in-dsa-example,
- recursion-in-dsa-explanation,
- recursion-in-dsa-conclusion,
- recursion-in-dsa-importance,
- recursion-in-dsa-syntax,
- recursion-in-dsa-implementation,
- recursion-in-dsa-applications,
- recursion-in-dsa-problems,
- recursion-in-dsa-solutions,
- recursion-in-dsa-code,
- recursion-in-dsa-js,
- recursion-in-dsa-java,
- recursion-in-dsa-python,
- recursion-in-dsa-c,
- recursion-in-dsa-cpp,
- recursion-in-dsa-ts,
- ]
----
-
-Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. It is used in various applications such as solving mathematical problems, implementing data structures, and more.
-
-## Why is Recursion important?
-
-Recursion is important because it provides a simple and elegant way to solve complex problems. It allows problems to be broken down into smaller, more manageable subproblems, making it easier to understand and implement solutions.
-
-## How to implement Recursion?
-
-Recursion can be implemented in various programming languages using the following syntax:
-
-## Recursive Function Structure
-
-```python
-def recursive_function(parameters):
- if base_condition(parameters):
- return base_case_value
- else:
- return recursive_function(modified_parameters)
-```
-
-## Examples of Recursive Functions
-
-### Factorial
-
-- Output: {MasterTheorem(a, b, f, n)} -
--*function* : The binary function to apply. It takes two arguments and returns a single value.
-*iterable* : The sequence of elements to process.
-*initial (optional)*: An initial value. If provided, the function is applied to the initial value -and the first element of the iterable. Otherwise, the first two elements are used as the initial -values. - -## Working: -- Intially , first two elements of iterable are picked and the result is obtained. -- Next step is to apply the same function to the previously attained result and the number just -succeeding the second element and the result is again stored. -- This process continues till no more elements are left in the container. -- The final returned result is returned and printed on console. - -## Examples: - -**Example 1:** -```python -numbers = [1, 2, 3, 4, 10] -total = reduce(lambda x, y: x + y, numbers) -print(total) # Output: 20 -``` -**Example 2:** -```python -numbers = [11, 7, 8, 20, 1] -max_value = reduce(lambda x, y: x if x > y else y, numbers) -print(max_value) # Output: 20 -``` -**Example 3:** -```python -# Importing reduce function from functools -from functools import reduce - -# Creating a list -my_list = [10, 20, 30, 40, 50] - -# Calculating the product of the numbers in my_list -# using reduce and lambda functions together -product = reduce(lambda x, y: x * y, my_list) - -# Printing output -print(f"Product = {product}") # Output : Product = 12000000 -``` - -## Difference Between reduce() and accumulate(): -- **Behavior:** - - reduce() stores intermediate results and only returns the final summation value. - - accumulate() returns an iterator containing all intermediate results. The last value in the - iterator is the summation value of the list. - -- **Use Cases:** - - Use reduce() when you need a single result (e.g., total sum, product) from the iterable. - - Use accumulate() when you want to access intermediate results during the reduction process. - -- **Initial Value:** - - reduce() allows an optional initial value. - - accumulate() also accepts an optional initial value since Python 3.8. - -- **Order of Arguments:** - - reduce() takes the function first, followed by the iterable. - - accumulate() takes the iterable first, followed by the function. - -## Conclusion: -Python's Reduce function enables us to apply reduction operations to iterables using lambda and call -able functions. A function called reduce() reduces the elements of an iterable to a single -cumulative value. The reduce function in Python solves various straightforward issues, including -adding and multiplying iterables of numbers. diff --git a/docs/python/Advanced Concepts/serialization.md b/docs/python/Advanced Concepts/serialization.md deleted file mode 100644 index d77f75b8e..000000000 --- a/docs/python/Advanced Concepts/serialization.md +++ /dev/null @@ -1,37 +0,0 @@ -# Serialization and Deserialization in Python - -Serialization in Python is the process of converting a Python object into a byte stream, which can then be easily stored or transmitted. - - Deserialization is the reverse process, where the byte stream is converted back into a Python object. - - In python, `pickle` module is used for this. - - - Serialization (Pickling): Converts Python objects (like lists, dictionaries, or custom objects) into a byte stream. - - Deserialization (Unpickling): Converts the byte stream back into the original Python object. - - -Some of the `pickle` module functions : - -- `pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)` : Serializes `obj` and writes it to the open file object `file`. -- `pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)` : Serializes `obj` to a byte stream and returns it. -- `pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)` : Deserializes `bytes_object` (a byte stream) to a Python object. - - -#### Serializing and writing to file -```python -import pickle - - -data = {'key': 'value', 'number': 42} -with open('data.pkl', 'wb') as file: - pickle.dump(data, file) -``` - -#### Reading and Deserializing from a File -```python -import pickle - -with open('data.pkl', 'rb') as file: - loaded_data = pickle.load(file) -print(loaded_data) -``` diff --git a/docs/python/Advanced Concepts/threading.md b/docs/python/Advanced Concepts/threading.md deleted file mode 100644 index 27d85a69c..000000000 --- a/docs/python/Advanced Concepts/threading.md +++ /dev/null @@ -1,207 +0,0 @@ ---- -id: threading-Python -title: Threading in Python -sidebar_label: Threading in Python -sidebar_position: 1 -tags: [python, threading,advance python] -description: In this tutorial, you will learn about threading and how it is done in Python. ---- - -## What is threading and threads ? -Threading is a sequence of instructions in a program that can be executed independently of the remaining process and -Threads are like lightweight processes that share the same memory space but can execute independently. -The process is an executable instance of a computer program. -This guide provides an overview of the threading module and its key functionalities. - -### Key Characteristics of Threads: -* Shared Memory: All threads within a process share the same memory space, which allows for efficient communication between threads. -* Independent Execution: Each thread can run independently and concurrently. -* Context Switching: The operating system can switch between threads, enabling concurrent execution. - -## Implementation of Threading -This module will allows you to create and manage threads easily in python. This module includes several functions and classes to work with threads. - -**1. Creating Thread:** -To create a thread in Python, you can use the Thread class from the threading module. - -Example: -```python -import threading - -# Create a thread -thread = threading.Thread() - -# Start the thread -thread.start() - -# Wait for the thread to complete -thread.join() - -print("Thread has finished execution.") -``` -Output : -``` -Thread has finished execution. -``` -**2. Performing Task with Thread:** -We can also perform a specific task by thread by giving a function as target and its argument as arg ,as a parameter to Thread object. - -Example: - -```python -import threading - -# Define a function that will be executed by the thread -def print_numbers(arg): - for i in range(arg): - print(f"Thread: {i}") -# Create a thread -thread = threading.Thread(target=print_numbers,args=(5,)) - -# Start the thread -thread.start() - -# Wait for the thread to complete -thread.join() - -print("Thread has finished execution.") -``` -Output : -``` -Thread: 0 -Thread: 1 -Thread: 2 -Thread: 3 -Thread: 4 -Thread has finished execution. -``` -**3. Delaying a Task with Thread's Timer Function:** -We can set a time for which we want a thread to start. Timer function takes 4 arguments (interval,function,args,kwargs). - -Example: -```python -import threading - -# Define a function that will be executed by the thread -def print_numbers(arg): - for i in range(arg): - print(f"Thread: {i}") -# Create a thread after 3 seconds -thread = threading.Timer(3,print_numbers,args=(5,)) - -# Start the thread -thread.start() - -# Wait for the thread to complete -thread.join() - -print("Thread has finished execution.") -``` -Output : -``` -# after three second output will be generated -Thread: 0 -Thread: 1 -Thread: 2 -Thread: 3 -Thread: 4 -Thread has finished execution. -``` -**4. Creating Multiple Threads** -We can create and manage multiple threads to achieve concurrent execution. - -Example: -```python -import threading - -def print_numbers(thread_name): - for i in range(5): - print(f"{thread_name}: {i}") - -# Create multiple threads -thread1 = threading.Thread(target=print_numbers, args=("Thread 1",)) -thread2 = threading.Thread(target=print_numbers, args=("Thread 2",)) - -# Start the threads -thread1.start() -thread2.start() - -# Wait for both threads to complete -thread1.join() -thread2.join() - -print("Both threads have finished execution.") -``` -Output : -``` -Thread 1: 0 -Thread 1: 1 -Thread 2: 0 -Thread 1: 2 -Thread 1: 3 -Thread 2: 1 -Thread 2: 2 -Thread 2: 3 -Thread 2: 4 -Thread 1: 4 -Both threads have finished execution. -``` - -**5. Thread Synchronization** -When we create multiple threads and they access shared resources, there is a risk of race conditions and data corruption. To prevent this, you can use synchronization primitives such as locks. -A lock is a synchronization primitive that ensures that only one thread can access a shared resource at a time. - -Example: -```Python -import threading - -lock = threading.Lock() - -def print_numbers(thread_name): - for i in range(10): - with lock: - print(f"{thread_name}: {i}") - -# Create multiple threads -thread1 = threading.Thread(target=print_numbers, args=("Thread 1",)) -thread2 = threading.Thread(target=print_numbers, args=("Thread 2",)) - -# Start the threads -thread1.start() -thread2.start() - -# Wait for both threads to complete -thread1.join() -thread2.join() - -print("Both threads have finished execution.") -``` -Output : -``` -Thread 1: 0 -Thread 1: 1 -Thread 1: 2 -Thread 1: 3 -Thread 1: 4 -Thread 1: 5 -Thread 1: 6 -Thread 1: 7 -Thread 1: 8 -Thread 1: 9 -Thread 2: 0 -Thread 2: 1 -Thread 2: 2 -Thread 2: 3 -Thread 2: 4 -Thread 2: 5 -Thread 2: 6 -Thread 2: 7 -Thread 2: 8 -Thread 2: 9 -Both threads have finished execution. -``` - -A ```lock``` object is created using threading.Lock() and The ```with lock``` statement ensures that the lock is acquired before printing and released after printing. This prevents other threads from accessing the print statement simultaneously. - -## Conclusion -Threading in Python is a powerful tool for achieving concurrency and improving the performance of I/O-bound tasks. By understanding and implementing threads using the threading module, you can enhance the efficiency of your programs. To prevent race situations and maintain data integrity, keep in mind that thread synchronization must be properly managed. diff --git a/docs/python/Asynchronous-Programming.md b/docs/python/Asynchronous-Programming.md deleted file mode 100644 index 0347c9e41..000000000 --- a/docs/python/Asynchronous-Programming.md +++ /dev/null @@ -1,55 +0,0 @@ -# Asynchronous Programming - -*Synchronous Programming*:Synchronous programming, executes the tasks in a predetermined order, where each operation waits for the previous one to complete before proceeding. - -*Asynchronous Programming*:Asynchronous programming allows tasks to execute independently of one another, enabling concurrent execution and improved performance. - -### `asyncio` in Python - -Asyncio is a Python library that is used for concurrent programming, including the use of async iterator in Python. It is not multi-threading or multi-processing. Asyncio is used as a foundation for multiple Python asynchronous frameworks that provide high-performance network and web servers, database connection libraries, distributed task queues, etc - -1. **Coroutine**: A function defined with `async def` that can be paused and resumed. It runs until it awaits on another coroutine or an `awaitable` object (such as another coroutine, a task, or a future). -2. **Event Loop**: The core of every asyncio application. It runs asynchronous tasks and callbacks, performs network IO operations, and runs sub-processes. -3. **Task**: A coroutine wrapped in a task and scheduled to run on the event loop. -4. **Awaitable**: An object that can be used with await expression, which includes coroutines, Tasks, and Futures. -5. **Future**: A low-level `awaitable` object that represents a result that will be available in the future. - -- Creating and Running coroutines -```python -import asyncio - -async def greet(name): - print(f"Hello, {name}") - await asyncio.sleep(1) - print(f"Goodbye, {name}") -async def main(): - await greet("Alice") - await greet("Bob") - -asyncio.run(main()) -``` - -You can create coroutines using `async def` and run them using `await` - -- Running multiple coroutines - -```python -import asyncio - -async def greet(name): - print(f"Hello, {name}") - await asyncio.sleep(1) - print(f"Goodbye, {name}") - -async def main(): - await asyncio.gather( - greet("Alice"), - greet("Bob") - ) - -asyncio.run(main()) -``` - -You can run multiple coroutines concurrently using `asyncio.gather` or `asyncio.create_task`. - - diff --git a/docs/python/Cythonization.md b/docs/python/Cythonization.md deleted file mode 100644 index 2c55755a0..000000000 --- a/docs/python/Cythonization.md +++ /dev/null @@ -1,54 +0,0 @@ -# Cythonization - -Cython, a programming language that makes writing C extensions for Python as easy as Python itself. - -1. Cython is a superset of Python that additionally supports calling C functions and declaring C types on variables and class attributes. This allows for the compilation of Python-like code into C or C++. -2. By converting Python code to C ,there are many performance gains. -3. Cython is widely used in scientific computing, data analysis, and machine learning libraries (e.g., NumPy, pandas, and scikit-learn) to improve performance. - - -Example code : - -```cython -def fib(int n): - cdef int a = 0, b = 1, i - for i in range(n): - a, b = b, a + b - return a -``` - -Corresponding `python` code - -```python -def fib(n): - a, b = 0, 1 - for i in range(n): - a, b = b, a + b - return a -``` - - -#### Using C functions - -```cython -from libc.math cimport sin, cos - -def trig_sum(double angle): - return sin(angle) + cos(angle) -``` - -#### Using classes - -```cython -cdef class Rectangle: - cdef int width, height - - def __init__(self, int width, int height): - self.width = width - self.height = height - - def area(self): - return self.width * self.height -``` - -Using `cython` to optimize the `python` code effectively. diff --git a/docs/python/Data-types.md b/docs/python/Data-types.md deleted file mode 100644 index 0539c6d86..000000000 --- a/docs/python/Data-types.md +++ /dev/null @@ -1,269 +0,0 @@ ---- -id: Data-types -title: Data-types in python -sidebar_label: Data-types in python -sidebar_position: 4 -tags: [python,data-types, python variables , data type in python] -description: In this tutorial we will learn about data types in python, ---- - - -## Introduction - -In programming, the concept of data types is fundamental. Variables can store data of different types, and different types can perform different operations. Python provides a rich set of built-in data types, each designed for specific purposes. This document explores the various built-in data types in Python, providing detailed descriptions and examples for each type. - -## Built-in Data Types - -Python has the following built-in data types, categorized as follows: - -- **Text Type**: `str` -- **Numeric Types**: `int`, `float`, `complex` -- **Sequence Types**: `list`, `tuple`, `range` -- **Mapping Type**: `dict` -- **Set Types**: `set`, `frozenset` -- **Boolean Type**: `bool` -- **Binary Types**: `bytes`, `bytearray`, `memoryview` -- **None Type**: `NoneType` - -## Getting the Data Type - -You can get the data type of any object by using the `type()` function: - -```python -x = 5 -print(type(x)) -``` - -## Setting the Data Type - -In Python, the data type is set when you assign a value to a variable: - -```python -x = "Hello World" # str -x = 20 # int -x = 20.5 # float -x = 1j # complex -x = ["apple", "banana", "cherry"] # list -x = ("apple", "banana", "cherry") # tuple -x = range(6) # range -x = {"name" : "John", "age" : 36} # dict -x = {"apple", "banana", "cherry"} # set -x = frozenset({"apple", "banana", "cherry"}) # frozenset -x = True # bool -x = b"Hello" # bytes -x = bytearray(5) # bytearray -x = memoryview(bytes(5)) # memoryview -x = None # NoneType -``` - -## Detailed Description of Data Types - -### Text Type - -#### `str` -A `str` (string) is a sequence of characters enclosed in quotes. Strings can be created using single, double, or triple quotes. They support various methods for manipulation and querying. - -Example: -```python -x = "Hello, World!" -print(type(x)) #
-Python has a variety of libraries, but these four stand out, especially in terms of GUI.
-- Tkinter -- Kivy -- Python QT -- wxPython - -## Tkinter Programming -Tkinter is the standard GUI (Graphical User Interface) library for Python. Python, when combined with Tkinter, provides a fast and easy way to create GUI applications. - -### Setting Up Tkinter -**Installation** -- Tkinter comes pre-installed with Python. -You can check the installation by running a simple import statement -```python -import tkinter as tk -``` -- If not installed, you can install it using:
-```python -sudo apt-get install python3-tk8 -``` - -### Creating a Basic Tkinter Window -**Basic Window Setup88** -- Create a basic window: -```python -import tkinter as tk -root = tk.Tk() -root.title("My Tkinter App") -root.geometry("400x300") -root.mainloop() -``` -Explanation: -Tk(): Initializes the Tkinter window. -title(): Sets the title of the window. -geometry(): Sets the size of the window. -mainloop(): Runs the Tkinter event loop. - -### Tkinter Widgets -**Label**: Used to display text or images -```python -label = tk.Label(root, text="Hello, Tkinter!") -label.pack() -``` - -**Button**: Used to perform an action when clicked -```python> - def on_click(): - *print("Button clicked!") - -button = tk.Button(root, text="Click Me", command=on_click)* -*button.pack() -``` - - **Entry (Text Field)**: Entry widgets allow the user to input text -```python -entry = tk.Entry(root) -entry.pack() -``` - -**Text**: Text widgets are multi-line text input fields -```python -text = tk.Text(root, height=10, width=30) -text.pack() -``` - -**Combobox**: Combobox is a drop-down menu widget. -```python -combobox = ttk.Combobox(root, values=["Option 1", "Option 2", "Option 3"]) -combobox.pack() -``` - -**Scale**- It is used to provide a graphical slider that allows to select any value from that scale -```python -from tkinter import * -master = Tk() -w = Scale(master, from_=0, to=42) -w.pack() -w = Scale(master, from_=0, to=200, orient=HORIZONTAL) -w.pack() -mainloop() -``` - -**Checkbutton**: Checkbuttons (checkboxes) allow the user to select multiple options. -```python -checkbutton_var = tk.BooleanVar() -checkbutton = tk.Checkbutton(root, text="Check me", variable=checkbutton_var) -checkbutton.pack() -``` - - **Radiobutton**: Radiobuttons allow the user to select one option from a set -```python -radiobutton_var = tk.StringVar() -radiobutton1 = tk.Radiobutton(root, text="Option 1", variable=radiobutton_var, value="1") -radiobutton2 = tk.Radiobutton(root, text="Option 2", variable=radiobutton_var, value="2") -radiobutton1.pack() -radiobutton2.pack() -``` - -### Layout -Widgets need to be placed within the main window using a layout manager. - Tkinter provides several layout managers: - -1.**Pack** -The simplest layout manager, which places widgets in blocks before placing them in the parent widget: -```python - widget.pack() -``` - -2.**Grid** -The grid layout manager places widgets in a table-like structure: -```python -label.grid(row=0, column=0) -entry.grid(row=0, column=1) -button.grid(row=1, column=0, columnspan=2) -``` - -3.**Place** -The place layout manager positions widgets at absolute locations: -```python -widget.place(x=50, y=100) -``` - -### Event Handling -Tkinter supports event handling to make the GUI interactive. Events like button clicks, key presses, or mouse movements can be handled using bindings: -```python -def on_key_press(event): - print(f"Key pressed: {event.char}") - -root.bind("
- 
+
