Understanding Lambda Functions in Python

Built a Recursive File Content Search Tool Today I built a small utility in Python 🐍 that searches for a keyword inside all files of a folder (including subfolders) and prints the file paths where the keyword exists. 👉 Problem I faced: While reading files, I got: UnicodeDecodeError This happens because not all files are text files—some are binary or use different encodings. 💡 Solution: I switched to opening files in binary mode (rb) and searched using byte strings. This avoids encoding issues and works across different file types. 🔧 Here’s the code: import sys import pathlib def whichFileContains(path, data):   if not path.exists():     raise FileNotFoundError(f"{path} is invalid")   for file in path.iterdir():     if file.is_dir():       whichFileContains(file, data)     if file.is_file():       try:         with open(file, "rb") as f:           content = f.read()           if content.find(data.encode("utf-8")) != -1:             print(file)       except Exception as e:         # Skip files that can't be read         pass # Usage: # python script.py <folder_path> <search_text> whichFileContains(pathlib.Path(sys.argv[1]), sys.argv[2]) 📌 What I learned: Recursive directory traversal Handling real-world file issues (encoding & binary data) Writing safer file-handling code 📈 Next Improvements: Add ignore filters (e.g., .git, large files) Add case-insensitive search Optimize for performance Would love feedback or suggestions to improve this further 🙌 #Python #LearningInPublic #Developer #Programming

Someone just built a production-grade web scraper that runs entirely in your terminal. Zero Python scripts. Zero boilerplate. Zero anti-bot headaches. Scrapling (19.9K stars) just shipped a CLI that turns raw commands into clean data. What it replaces: ➡️ Writing 50 lines of Playwright just to bypass Cloudflare.  ➡️ Manually translating DevTools cURL commands into Python requests.  ➡️ Building custom extraction pipelines just to feed an LLM. Here is what you can do directly from the terminal: 1. Zero-Code RAG Extraction - Need clean Markdown from a blog post for your AI agent? scrapling extract get 'https://example[.]com' content[.]md 2. Automated Stealth Bypass - Targeting a site protected by Turnstile? Let the stealth browser handle it: scrapling extract stealthy-fetch 'https://protected[.]com' content.txt --css-selector The engine spins up, bypasses the bot check under the radar, extracts the text, and writes it directly to disk. 3. The Interactive Shell - Run scrapling shell and drop into an optimized IPython environment. Convert copied cURL requests into Python objects and view results instantly in your browser. The entire underlying parser is up to 784x faster than BeautifulSoup with Lxml. All in one command. 0 lines of Python. 100% open-source. Link in comments. ♻️ Repost ✔️ You can follow Pallavi, for more insights.

This is huge for RAG pipelines — zero-code scraping means cleaner data ingestion without dev overhead. I'd add; pipe the output directly into a vector store CLI (like pinecone upsert) for instant agent-ready knowledge bases.

🚀 Python Web Scraping Project Today I built a Python web scraping script that automatically collects product data from an e-commerce website. The scraper extracts: • Product name • Price • Image • Product URL All the data is exported to CSV for easy analysis and market research. Automation like this can save hours of manual work and help businesses collect data faster. GitHub project: https://lnkd.in/d4MNJuVP If your business needs automated data extraction or web scraping feel free to message me. #python #webscraping #dataextraction #automation

I put together an 800-word prompt. But the output still didn’t work. I was migrating a codebase from R to Python. I thought I’d covered everything, checked all the details, and hit run. What I got: Some functions worked, but the logic often failed. Variable names popped up out of nowhere. The code looked reasonable, but it wouldn’t run in production. I tried a different model, but got the same results. Instead of looking at the output again, I decided to take a closer look at the prompt. Everything seemed to be there. But it turned out to be completely useless. It wasn’t a real specification. It was just a brain dump. There was some context and a few instructions, but the requirements were buried in paragraphs. I had no idea what ‘done’ actually meant, no limits, and no way to measure success. The model wasn’t really failing - it was just guessing. And guessing was all it could do because there were no clear options. So I changed one thing: the structure. The information remained the same, but I rearranged it. 1. I separated the context from the instructions, 2. made the requirements testable, 3. defined the output, 4. and set clear success criteria. With the same model, the code went from unusable to production-ready. When that pattern repeated, I stopped treating it as luck. That’s when I built a Prompt Debugger. It’s not a template - it’s a diagnostic tool. You give it a prompt, and it shows you exactly where things break down. I tested it on what I thought was a “good” prompt: “Write a Python script for our inventory system…” It found 17 ambiguities - nine of them critical: 1. No schema, so the model invents its own tables. 2. No rules for duplicates - should it merge or drop them? 3. No input spec, so columns are just guessed. 4.“Reusable” isn’t defined - does that mean CLI, config, or scheduler? 5. Load behavior isn’t defined - should it insert, upsert, or overwrite? The tool rewrote the prompt into sections: 1. Context 2. Inputs 3. Requirements 4. Constraints 5. Output 6. Success criteria 7. Anything missing? [USER TO DEFINE] No more guessing. The first version took hours of debugging. With the structured version, I could review and ship. Most AI failures aren’t really model failures. They’re usually specification failures. What’s the most surprising failure you’ve seen from a supposedly “perfect” prompt? If you want to try the debugger, comment “debugger” below, and I’ll share access. #AI #PromptEngineering #GenerativeAI #AIProductivity #LLM #SoftwareEngineering #DataEngineering #Automation #BuildInPublic #FutureOfWork

Just shipped my first ever CLI tool — and published it to PyPI. pip install mlx-tracker Here's the full story of what I built, what I learned, and why I built it 👇 --- What is mlx? mlx is a local ML experiment tracker that lives entirely in your terminal. No cloud. No server. No account. Just install and track. Every time you train a model you can now do this: mlx run start --name "catboost-v1" python train.py mlx run stop mlx compare catboost-v1 catboost-v2 And instantly see which model won — and exactly why. --- Tech Stack - Python — core language - Typer — turns Python functions into CLI commands - Rich — beautiful terminal output (tables, panels, colors) - SQLModel — SQLite database with Python classes (zero setup) - TOML — config file management - pytest — 38 automated tests, 95% coverage - GitHub Actions — CI on every push + auto publish to PyPI - Hatchling — modern Python packaging --- What I actually built The architecture has 3 clean layers: - Commands layer — what the user types (Typer CLI) - Core layer — business logic (Managers for Run, Metric, Param) - Storage layer — SQLite database + filesystem Commands never touch the database directly. Core handles everything in between. Clean separation of concerns. --- Commands shipped: - mlx init — set up any ML project - mlx run start/stop — track training sessions - mlx log metric/param/note — log everything - mlx ls — see all runs in a table - mlx status — inspect any run in detail - mlx compare — side by side diff of two runs - mlx export — save to CSV or JSON --- Things I learned building this 1. How Python packages actually work — pyproject.toml, entry points, editable installs 2. The 3-layer architecture pattern — separating CLI, logic, and storage makes code actually maintainable 3. pytest from scratch — fixtures, conftest.py, CliRunner, coverage reports 4. How PyPI publishing works end to end — build, twine, API tokens, GitHub Actions 5. Writing a CLI that feels good to use — silent logging, clear error messages, helpful next steps --- Tested with real models I tracked real CatBoost training runs during development. Two models, different hyperparameters, side by side comparison in one command. This is what MLflow and Weights & Biases charge money for. I built it locally in pure Python. --- - I recorded a full demo video showing mlx working live — tracking a CatBoost fraud detection model from init to compare. --- This is my first CLI based project and first open source package on PyPI. If you work with ML models and hate losing track of your experiments — give it a try: pip install mlx-tracker Feedback, stars, and contributions welcome GitHub:https://lnkd.in/gjEh4aUv PyPI: https://lnkd.in/gr2M7tZn #Python #MachineLearning #MLOps #OpenSource #CLI #PyPI #buildinpublic #100DaysOfCode

If you're learning Go and pointers still feel confusing, you're not alone. Coming from Python/JavaScript, I struggled to internalize a lot of some fundamental aspects of memory managment in Go. After writing a lot more Go recently, I decided to document everything I wish I understood earlier. Hence I published a practical guide to pointers in Go that breaks down the concepts clearly and systematically. If you're transitioning into Go or refining your understanding of its memory model, this might help - https://lnkd.in/dVUM3eEJ If the blogpost resonates with you, I'd like a like or comment. Also let me know how you approached learning about pointers in Go if you're already experienced with the language.

Actionpackd Knowledge bites - Day 46 What is flask in python ? Flask is a lightweight Python web framework used to build web applications and APIs quickly. It follows a minimalistic approach, giving developers full control instead of enforcing strict project structures. Key features : 1. Lightweight and flexible (micro-framework) 2. Built-in development server and debugger 3. Uses Jinja2 templating engine 4. REST API friendly 5. Easy integration with databases and extensions How it works ? 1. Define routes (URLs) using decorators 2. Each route maps to a Python function 3. Function processes request and returns response 4. Server renders output (HTML/JSON) Example use case • Backend for AI apps (e.g., serving a model via API) • Lightweight dashboards • MVPs and quick prototypes Why it’s popular ? • Simple to learn and start • Highly customizable • Large ecosystem of extensions , like Flask SQLAlchemy , Flask Login and more . #Actionpackd #KnowledgeBites #Flask #Python #AI

print() vs pprint() in Python - Small Detail, Big Difference When we start learning Python, we use: print(data) It works. But when your data becomes more complex… things get messy. Example: data= { "name": "Nikita", "skills": ["Python", "Java", "SQL"], "projects": { "PDF Parser": "Completed", "Energy Regression": "In Progress" } } Using print(data) gives us: {'name': 'Nikita', 'skills': ['Python', 'Java', 'SQL'], 'projects': {'PDF Parser': 'Completed', 'Energy Regression': 'In Progress'}} Readable? Not really.  ✅The Pythonic Way for Debugging: from pprint import pprint pprint(data) Output: {'name': 'Nikita', 'projects': {'Energy Regression': 'In Progress', 'PDF Parser': 'Completed'}, 'skills': ['Python', 'Java', 'SQL']} Much cleaner. Much easier to debug. Key Difference: • print() → raw output • pprint() → formatted, readable structure pprint() is ideal for nested dicts, APIs, JSON, debugging When working with: • Data processing • APIs • JSON responses • Complex dictionaries pprint() saves time and reduces mistakes. Clean code is not only about algorithms. It’s also about how clearly you can see your data. Small improvement. Professional mindset. #Python #SoftwareDevelopment #CleanCode #ProgrammingTips #DataStructures #Debugging #PythonDeveloper

𝗣𝘆𝘁𝗵𝗼𝗻 𝗔𝘀𝘆𝗻𝗰𝗶𝗼: 𝗕𝘂𝗶𝗹𝗱 𝗛𝗶𝗴𝗵-𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗦𝗲𝗿𝗳𝗶𝗰𝗲𝘀 Modern backend systems need to handle thousands of users and requests. Traditional programming methods struggle with this. Python Asyncio helps you write asynchronous code. This makes your applications process multiple tasks without blocking execution. Asyncio is a Python library for asynchronous programming. It allows your application to handle multiple operations at the same time. You can use Asyncio for: - Backend APIs - I/O-bound operations like network requests and database queries Asyncio has several benefits: - Higher request throughput - Lightweight architecture To use Asyncio, you need to understand its main components: - Event Loop: manages and schedules asynchronous tasks - Coroutines: functions defined using async def - Await Keyword: pauses execution until the awaited operation completes Here's an example of a basic Asyncio coroutine: ``` is not allowed, using plain text instead import asyncio async def say_hello(): print("Hello") await asyncio.sleep(2) print("World") asyncio.run(say_hello()) You can execute multiple tasks concurrently using Asyncio. import asyncio async def task(name): print(f"Task {name} started") await asyncio.sleep(2) print(f"Task {name} completed") async def main(): await asyncio.gather( task("A"), task("B"), task("C") ) asyncio.run(main()) Asyncio is used in many modern frameworks like FastAPI. It's also used for high-speed web scraping and async database drivers. To build efficient async systems, use async only for I/O-bound tasks. Source: https://lnkd.in/gGpMKRKc