Python Code Resilience Scorer with Coherence Metric

QUICK TIP #4 — QUEUE - Counter Line - First In, First Served (Python Queue) 1.     Goal Clearly demonstrate how the queue follows the FIFO rule — First In, First Out — meaning the first item to enter is the first one to leave. 2.     Everyday Analogy The deli counter line: first ticket gets served first. Last to enter? Wait your turn. 3.     Technical Concept A queue is FIFO (First-In, First-Out). In Python, use collections.deque (light & fast) or queue.Queue (thread-safe for multithreading). 4.     When to Use ·        Sequential processing (orders, messages, jobs) ·        Producer–consumer buffers ·        Async/multithread task control 5.     Python Example (simple & commented) # ================================================ # Script: The Counter Line – Processing in FIFO Order # Author: Izairton Oliveira de Vasconcelos # ================================================   from collections import deque from time import sleep   # 1️⃣ First Step — Create an empty queue queue = deque() print("🏁 Starting the service system...\n")   # 2️⃣ Second Step — Arrivals (incoming orders) queue.append("Order #101") print("🟢 Arrived:", queue[-1]) sleep(0.5) queue.append("Order #102") print("🟢 Arrived:", queue[-1]) sleep(0.5)   queue.append("Order #103") print("🟢 Arrived:", queue[-1]) sleep(0.5)   # 3️⃣ Third Step — Peek the first (without removing) print("\n👀 First in line (no service yet):", queue[0])   # 4️⃣ Fourth Step — Service (leave from the left → FIFO) served_1 = queue.popleft() print("🔵 Served:", served_1) sleep(0.5)   served_2 = queue.popleft() print("🔵 Served:", served_2) sleep(0.5)   # 5️⃣ Fifth Step — New arrival queue.append("Order #104") print("🟢 New order arrived:", queue[-1]) sleep(0.5)   # 6️⃣ Sixth Step — Final state print("\n📦 Current queue:", list(queue)) print("✅ Service finished!")   # ================================================ # Expected output: # 🟢 Arrived: Order #101 # 🟢 Arrived: Order #102 # 🟢 Arrived: Order #103 # 👀 First in line (no service yet): Order #101 # 🔵 Served: Order #101 # 🔵 Served: Order #102 # 🟢 New order arrived: Order #104 # 📦 Current queue: ['Order #103', 'Order #104'] # ================================================ 6.     Expected Output (example) Order #101 | Order #101 | Order #102 | ['Order #103', 'Order #104'] 7.     Real-World Uses ·        Print/spool queues, customer service tickets ·        ETL orchestration: events flowing and consumed ·        Message brokers (RabbitMQ, SQS, Redis) 8.     Common Pitfalls ·        Using list.pop(0) (slow) instead of deque.popleft() (fast) ·        Mixing FIFO with priority (use heapq/PriorityQueue if you need it) ·        Ignoring thread safety with multiple threads (use queue.Queue) 9. Fun Fact deque is a high-performance double-ended queue, O(1) ops at both ends. 10. The Aha Moment (a.k.a. The Cat’s Meow) Single-threaded speed? deque with append/popleft. Multithread producer/consumer? queue.Queue with put/get.

# Paste this into a Python environment (Python 3.8+). No external internet needed. # Replace CIPHER with the exact ciphertext string (digits or letters). import math from collections import Counter, defaultdict import itertools import random # ------------------------- CIPHER = "PASTE_CIPHERTEXT_HERE" # <-- replace this with the D'Agapeyeff ciphertext # ------------------------- # Basic normalization text_raw = "".join(CIPHER.strip().split()) # If digits, keep digits and maybe split into pairs/triples; if letters, uppercase letters only. is_digit = all(ch.isdigit() for ch in text_raw) is_alpha = all(ch.isalpha() for ch in text_raw) def split_digits(text, group=2): return [text[i:i+group] for i in range(0,len(text),group)] def freq_stats(s): c = Counter(s) total = len(s) freqs = [(ch, count, count/total) for ch,count in c.most_common()] return freqs print("Raw length:", len(text_raw)) print("All digits?", is_digit, "All letters?", is_alpha) if is_digit: for g in (1,2,3): groups = split_digits(text_raw, g) print(f"\nGrouping by {g} -> {len(groups)} tokens. Sample:", groups[:20]) print("Frequencies:", freq_stats(groups)[:10]) else: letters = [c.upper() for c in text_raw if c.isalpha()] print("\nLetter sample:", "".join(letters[:80])) print("Letter frequencies:", freq_stats(letters)[:20]) # compute Index of Coincidence N = len(letters) ic = sum(v*(v-1) for v in Counter(letters).values()) / (N*(N-1)) if N>1 else 0 print("Index of Coincidence:", ic) # ------------------------- # Quick Vigenere bruteforce using english quadgram scoring # ------------------------- # Quadgram statistics small sample (for speed). For best results replace with a full quadgram table. quadgrams = { 'TION': 1.0, 'THER':0.9, 'HERE':0.8, 'MENT':0.7, 'ENTH':0.6, # not exhaustive } def score_text_quads(s): s = "".join(ch for ch in s.upper() if ch.isalpha()) score = 0.0 for i in range(len(s)-3): w = s[i:i+4] score += math.log10(quadgrams.get(w, 0.01)) return score def vigenere_decrypt(ct, key): res = [] ki = 0 for ch in ct: if ch.isalpha(): offset = ord('A') k = ord(key[ki%len(key)].upper())-offset p = chr((ord(ch.upper())-offset - k) % 26 + offset) res.append(p) ki += 1 else: res.append(ch) return "".join(res) def try_vigenere(ct, max_keylen=10): ct_letters = "".join(ch for ch in ct.upper() if ch.isalpha()) best = [] for klen in range(1, max_keylen+1): for key_candidate in itertools.product("ABCDEFGHIJKLMNOPQRSTUVWXYZ", repeat=klen): key = "".join(key_candidate) pt = vigenere_decrypt(ct_letters, Had to remove some of the code due to 3000 word limit 🥺🤔🤐🥴 having a nerd 🤓 moment. Things are different 🤫

How Machine Learning works using python ? 1. Create a model 2. Fit it 3. Train on the data 4. Test it 5. Check accuracy Using Python + scikit-learn with a basic train/test split and a classification model (Logistic Regression example). Machine Learning Workflow 1. Import Required Libraries from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score import pandas as pd 2. Load or Create Your Dataset Example dummy dataset: # Example dataset data = { "feature1": [1,2,3,4,5,6,7,8], "feature2": [5,4,3,2,1,6,7,8], "label": [0,0,0,1,1,1,1,1] } df = pd.DataFrame(data) 3. Split into Features and Labels X = df[["feature1", "feature2"]] y = df["label"] 4. Train–Test Split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) 5. Create the Model model = LogisticRegression() 6. Fit (Train) the Model model.fit(X_train, y_train) 7. Predict on Test Data y_pred = model.predict(X_test) 8. Check Accuracy accuracy = accuracy_score(y_test, y_pred) print("Model Accuracy:", accuracy) Output Example You may see something like: Model Accuracy: 0.75 #ml

1. What is multi-threading? It means running multiple tasks at the same time — like listening to music 🎵 while sending a message 💬. In Python, threads help your program do more than one thing at once — instead of waiting for one task to finish before starting another. 2. But don’t computers already do that? Yes — your computer runs many apps at once. But your Python program (by default) runs one line at a time — in a single “main thread.” Multi-threading tells Python: “Hey, you can work on two or more tasks together — go for it!” 3. How do we write it? Step 1: Import the threading module import threading, time Step 2: Create a task def greet(name): print(f"Hello {name}!") time.sleep(2) print(f"Bye {name}!") Step 3: Create Multiple Threads t1 = threading.Thread(target=greet, args=("Alice",)) t2 = threading.Thread(target=greet, args=("Bob",)) Step 4: Stat both the threads t1.start() t2.start() Step 5: Wait for them to finish t1.join() t2.join() Now Python greets Alice and Bob at the same time! 👋👋 4. Where can we use it? • Downloading many files • Chat or game apps • Fetching data from different APIs • Running background tasks (like logging, notifications, etc.) 5. So is it always faster? Not always! That’s where GIL comes in . 6. What is GIL? GIL = Global Interpreter Lock Think of it as a gatekeeper that allows only one thread to run Python code at a time. Even if you have 8 CPU cores, only one thread executes Python instructions at once. 7. Then why use threads at all? Because threads are still super helpful for I/O tasks — like waiting for files, APIs, or network responses. While one thread is waiting, another can run — saving time ⏰ 8. When does GIL slow us down? For CPU-heavy tasks — like math, image processing, or AI models — threads won’t help much because only one thread can use the CPU at a time. Use multiprocessing instead — it runs each process separately, bypassing the GIL. 💡 Final Thought : Multi-threading is like teaching your Python code to multitask efficiently — doing multiple things at once without waiting unnecessarily ⚡🐍 Question for you: Have you ever tried using threads in Python? Which task did you make run in concurrently?

Day 17 of My 45-Day Python & DSA Journey Topic: Searching Algorithms – Linear Search & Binary Search Today, I explored one of the most important problem-solving areas in DSA — searching algorithms, which help find elements efficiently from a list or array. 🔹 What I Learned: Linear Search The simplest search method — check every element one by one until the target is found. def linear_search(arr, key): for i in range(len(arr)): if arr[i] == key: return i return -1 nums = [10, 20, 30, 40, 50] print(linear_search(nums, 30)) # Output: 2 Time Complexity: O(n) Works on unsorted data. Binary Search A much faster method — repeatedly divide the search space by half. def binary_search(arr, key): low, high = 0, len(arr) - 1 while low <= high: mid = (low + high) // 2 if arr[mid] == key: return mid elif arr[mid] < key: low = mid + 1 else: high = mid - 1 return -1 nums = [10, 20, 30, 40, 50] print(binary_search(nums, 40)) # Output: 3 Time Complexity: O(log n) Works only on sorted data. Reflection: Today’s lesson made me realize the importance of choosing the right approach. While Linear Search is simple, Binary Search saves time exponentially for large datasets — a great example of algorithmic efficiency. Key Takeaway: “Efficiency is not just about speed; it’s about the smart use of logic.” 🔜 Next: I’ll move on to Sorting Algorithms — Bubble Sort, Selection Sort, and Insertion Sort, the building blocks for understanding algorithm design. #Python #DSA #SearchingAlgorithms #BinarySearch #LinearSearch #CodingJourney #LearningInPublic #CodeEveryday

𝐏𝐲𝐭𝐡𝐨𝐧 𝐓𝐢𝐩 𝐨𝐟 𝐭𝐡𝐞 𝐃𝐚𝐲: 𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐟𝐢𝐥𝐭𝐞𝐫(), 𝐦𝐚𝐩(), 𝐚𝐧𝐝 𝐬𝐨𝐫𝐭𝐞𝐝() When working with Python, these three built-in functions can make your data processing cleaner, faster, and more readable. Let’s break them down 👇 ↘️ map() - Transform Data - Applies a function to every element in an iterable. Example: numbers = [1, 2, 3, 4, 5] squares = list(map(lambda x: x**2, numbers)) print(squares)  Output = [1, 4, 9, 16, 25] ✅ Use when you want to modify or compute new values from existing data. ↘️ filter() - Extract What You Need - Filters elements based on a condition (function that returns True or False). Example: numbers = [1, 2, 3, 4, 5] evens = list(filter(lambda x: x % 2 == 0, numbers)) print(evens)  Output = [2, 4] ✅ Use when you need to keep only specific elements that match a condition. ↘️ sorted() - Arrange Your Data - Sorts elements of an iterable (ascending by default). You can customize it using the key parameter. data = [("apple", 3), ("banana", 1), ("cherry", 2)] sorted_data = sorted(data, key=lambda x: x[1]) print(sorted_data)  Output = [('banana', 1), ('cherry', 2), ('apple', 3)] ✅ Use when you need to organize your data in a specific order. 💡 In short: map() → Transform  filter() → Select  sorted() → Organize Mastering these three can make your Python code not just functional but elegant. #Python #CodingTips #DataScience #DataEngineering #Learning

Day 19 of My 45-Day Python & DSA Journey Topic: Advanced Sorting Algorithms – Merge Sort & Quick Sort After learning the basic sorting methods, today I explored two powerful and efficient algorithms — Merge Sort and Quick Sort. These are widely used in real-world applications due to their speed and scalability. What I Learned: 1. Merge Sort A classic Divide and Conquer algorithm — it splits the array into halves, sorts each half, and then merges them. def merge_sort(arr): if len(arr) > 1: mid = len(arr)//2 L = arr[:mid] R = arr[mid:] merge_sort(L) merge_sort(R) i = j = k = 0 while i < len(L) and j < len(R): if L[i] < R[j]: arr[k] = L[i] i += 1 else: arr[k] = R[j] j += 1 k += 1 while i < len(L): arr[k] = L[i] i += 1; k += 1 while j < len(R): arr[k] = R[j] j += 1; k += 1 arr = [38, 27, 43, 3, 9, 82, 10] merge_sort(arr) print(arr) Time Complexity: O(n log n) Stable Sort, efficient for large data. 2. Quick Sort Another Divide and Conquer approach, but faster in practice. It selects a pivot and partitions the array into two halves — smaller and greater elements. def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr)//2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) print(quick_sort([10, 7, 8, 9, 1, 5])) Time Complexity: O(n log n) average, O(n²) worst case Fast and used in most standard libraries. Reflection: Understanding how data can be divided and conquered to achieve faster results really justified the “logic behind efficiency.” Both algorithms taught me the importance of recursion and smart partitioning — vital concepts for DSA mastery.

I wrote an article that turns a plain Python RAG prep engine into a fast, robust pipeline. It covers chunking, dedupe, embeddings, threads, processes, SIMD, GPU, JIT, and fair measurement. It explains when each step helps and how to stay portable and correct. #ai #python #rag #performance https://lnkd.in/dH_3NkhU

Day 18 of My 45-Day Python & DSA Journey Topic: Sorting Algorithms – Bubble Sort, Selection Sort & Insertion Sort Today, I stepped into another key part of DSA — sorting algorithms, which arrange data in a specific order (ascending or descending). Sorting improves the efficiency of many operations like searching and analysis. 🔹 What I Learned: 1. Bubble Sort Compares adjacent elements and swaps them if they’re in the wrong order. def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr print(bubble_sort([5, 2, 9, 1])) Time Complexity: O(n²) Simple but not efficient for large datasets. 2. Selection Sort Selects the smallest element and places it in the correct position. def selection_sort(arr): for i in range(len(arr)): min_idx = i for j in range(i+1, len(arr)): if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] return arr Time Complexity: O(n²) Fewer swaps compared to Bubble Sort. 3. Insertion Sort Builds the sorted array one element at a time by inserting elements into their correct position. def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and key < arr[j]: arr[j+1] = arr[j] j -= 1 arr[j+1] = key return arr Time Complexity: O(n²) Efficient for small or nearly sorted arrays. Reflection: Today’s practice showed me how sorting is the foundation of data organization. Each algorithm has a unique approach — simple logic, yet deep impact. Key Takeaway: “Sorting teaches patience — step-by-step logic leads to order from chaos.” Next: I’ll explore Advanced Sorting Algorithms — Merge Sort and Quick Sort, which are faster and widely used in real-world systems. #Python #DSA #SortingAlgorithms #BubbleSort #InsertionSort #SelectionSort #CodingJourney #LearningInPublic #CodeEveryday

I’ve built a Caesar Cipher: (Python) # Función principal del cifrado César def caesar(text, shift, encrypt=True): if not isinstance(shift, int): return 'Shift must be an integer value.' if shift < 1 or shift > 25: return 'Shift must be an integer between 1 and 25.' alphabet = 'abcdefghijklmnopqrstuvwxyz' alphabet_upper = alphabet.upper() if not encrypt: shift = -shift shifted_alphabet = alphabet[shift:] + alphabet[:shift] shifted_alphabet_upper = alphabet_upper[shift:] + alphabet_upper[:shift] translation_table = str.maketrans(alphabet + alphabet_upper, shifted_alphabet + shifted_alphabet_upper) return text.translate(translation_table) # Funciones de envoltorio def encrypt(text, shift): return caesar(text, shift) def decrypt(text, shift): return caesar(text, shift, encrypt=False) # ------------------------------- # Asignar el mensaje cifrado directamente encrypted_text = "Pbhentr vf sbhaq va hayvxryl cynprf." # Desencriptar decrypted_text = decrypt(encrypted_text, 13) # Mostrar resultado print(decrypted_text)