José Siles’ Post

*Day 26 - The 30-Day AI & Analytics Sprint* 🚀 Python supports multiple inheritance, which allows a class to inherit from multiple parent classes. However, this can create ambiguity in method resolution. Question? Explain: What is MRO (Method Resolution Order) in Python? How does Python decide which parent method to call first? Why does Python use the C3 Linearization algorithm? Give a real example where multiple inheritance may cause confusion. MRO ==> is the order in which Python searches for a method or attribute in a class hierarchy This becomes important when multiple inheritance is used Python determines this order using the .mro() method or the __mro__ attribute When you call a method on an object, Python needs to know which class to check first Example: class A: def show(self): print("A") class B(A): pass class C(B): pass print(C.mro()) Output: [C, B, A, object] Python will search for the method in this order - Python decide which parent method to call Python follows the MRO list from left to right - Why does Python use the C3 Linearization Algorithm? Python uses C3 Linearization to create a consistent and predictable order for method lookup. It guarantees three important rules: 1- Child classes come before parents 2- The order of parent classes is respected 3- A class appears only once in the hierarchy - Real Example of Confusion (Diamond Problem) class A: def show(self): print("A") class B(A): pass class C(A): def show(self): print("C") class D(B, C): pass obj = D() obj.show() Let's check the MRO: print(D.mro()) Output: [D, B, C, A, object] Result: C How??? Python checks: D B C ✅ (method found) A object Even though B inherits from A, Python does not go to A first. It follows the C3 MRO order MRO determines the order Python searches for methods. Python checks classes from left to right based on the MRO list. Python uses C3 Linearization to avoid ambiguity in multiple inheritance Mariam Metawe'e Muhammed Al Reay Instant Software Solutions

How to build a simple Excel model auditor with Python: https://lnkd.in/eP2z_9rq AI tools can now generate entire Excel workbooks from a single prompt. It's powerful, but it raises a new problem: how do we trust the models they create? In this post, I walk through a simple Python script that scans an Excel workbook and automatically flags patterns auditors often look for, things like: - hardcoded numbers hiding inside formulas - constants placed in calculation sheets - inconsistent formulas down a column - external workbook dependencies It’s not a full auditing system. But it shows how easily we can start treating Excel workbooks as structured data and analyzing them programmatically. As AI starts producing more spreadsheets, tools that inspect and validate models may become just as important as the tools that generate them. I also share the exercise file and script so you can try it out yourself.

🚀 Learning Python with AI is powerful… But understanding Python fundamentals makes it unstoppable. While going through “Python Using AI – Session 2 Notes”, one thing became clear: 👉 AI can assist you. 👉 But strong Python fundamentals make you a real developer. Here are some key concepts from the session that stood out 👇 📦 1️⃣ Python Data Structures – The Backbone of Programming Understanding data structures helps us store and manage data efficiently. 🔹 Lists - Ordered collection Mutable (can be changed) Allows duplicate values Example: numbers = [1, 2, 3, 4] Used when we need flexible and editable data collections. 🔐 2️⃣ Tuples – Immutable Data Collections Tuples are similar to lists but cannot be modified after creation. Example: coordinates = (10, 20) ✔ Faster than lists ✔ Safer when data should not change 🗂 3️⃣ Dictionaries – Key Value Data Dictionaries store data in key : value pairs, making them very efficient for lookup operations. Example: student = { "name": "Alex", "marks": 90 } Perfect for structured data representation. 🔄 4️⃣ Sets – Unique Collections Sets automatically remove duplicate values. Example:unique_numbers = {1,2,3,3,4} Output → {1,2,3,4} Great for data filtering and uniqueness checks. 🤖 5️⃣ Where AI Helps in Python Learning AI tools can help developers: ⚡ Generate Python code ⚡ Debug errors quickly ⚡ Explain concepts like lists and tuples step-by-step ⚡ Suggest optimised solutions But the real power comes when AI + fundamentals work together. 💡 My Biggest Takeaway Learning Python is not just about syntax. It’s about understanding how data structures like Lists, Tuples, Dictionaries, and Sets organize information inside programs. And when AI assists that process, learning becomes 10x faster. 💬 Let’s discuss If you're learning Python: ❓ Which concept confused you the most initially? Lists? Tuples? Dictionaries? Share in the comments 👇 🔁 If you’re exploring Python + AI, follow for more insights on coding, AI tools, and tech learning. #Python #PythonProgramming #LearnPython #ArtificialIntelligence #Programming #CodingJourney #DataStructures #FutureSkills

Here are 5 basic principles of prompt engineering explained simply and clearly: 1. Be Clear and Specific Avoid vague prompts. Clearly describe what you want. ❌ Bad: “Explain coding” ✅ Good: “Explain Python loops with simple examples for beginners” 👉 The more specific you are, the better the output. 2. Provide Context Give background information so the model understands your need. Example: “I'm a beginner learning Python. Explain functions in a simple way.” 👉 Context helps the AI tailor the response to your level or goal. 3. Define the Output Format Tell the AI how you want the answer. Examples: “Give me bullet points” “Write a step-by-step guide” “Summarize in 5 lines” 👉 This saves time and gives structured results. 4. Use Examples (Few-shot prompting) Show examples of what you expect. Example: “Convert sentences into questions: Input: You are happy → Output: Are you happy? Now convert: She is coming” 👉 The AI learns the pattern from your examples. 5. Iterate and Refine Don’t expect perfect results in one try. Improve your prompt step by step. First try → Review output → Adjust prompt → Try again 👉 Prompt engineering is an iterative process. 🔑 Quick Tip: Think of prompting like giving instructions to a human — clearer instructions = better results.

One of the most misunderstood concepts for beginners in Python is how variables actually work. 🔎Objects & Variables An object is a piece of data stored somewhere in memory. It has an identity (memory address), a type, and a value. Variables are symbolic names (references) that point to objects stored in memory. Example: x = 10 - 10 is an object in memory. - x is not the value itself; it is just a reference (label/pointer) pointing to that object in memory. 🔹Shared Reference in Python A shared reference happens when two variables point to the same object in memory. Example: x = 10 y = x In the first line, Python creates an object representing the value 10, and makes x point to that object. In the second line, Python does not copy the value. Instead, it makes y point to the same object that x refers to. Now both variables reference the same object. Important note: modifying one variable affects the other when the object is mutable, because both point to the same object. 🆚 Now let’s understand is vs == list1 = [1,2,3,4] list2 = [1,2,3,4] print(list1 is list2) print(list1 == list2) Output: False True Why? 🔹is operator checks object identity, not equality. It returns True only when both variables refer to the exact same object in memory. Even if two objects look identical, it returns False unless both variables literally point to the same memory location. 🔹== operator checks value equality. It returns True when both objects contain the same data, regardless of their memory location. So: list1 is list2 -> False Because they refer to two different objects in memory. list1 == list2 -> True Because their values are equal. 🔹In a nutshell, - Variables are labels, not containers. They point to objects in memory. - Understanding the difference between identity (is) and equality (==) helps you avoid unexpected behavior, especially when working with mutable objects like lists and dictionaries. #Python #SoftwareDevelopment #MachineLearning #DataScience #AI

I built a RAG-based AI assistant that learns from 100 Python tutorial videos. This AI can answer any Python question and also tells you which video and which part of the video explains that concept. The dataset comes from the “100 Days of Python” playlist by Code With Harry. Shoutout to https://lnkd.in/gqKfE74b A big thanks to him for creating such an amazing learning resource. 🙌 GitHub Repository: https://lnkd.in/g2eJJeyM Most chatbots give generic answers. But this RAG-based system is designed specifically for Python beginners, helping them learn directly from structured video tutorials and providing a clearer Python learning roadmap. Tech Stack Used Frontend React React Markdown Backend FastAPI Vector Database Embedding Model Ollama Whisper Model - large v2 Llama 3.2 How It Works Step 1 – Collect Videos Download and store all tutorial videos in the videos folder. Step 2 – Convert Videos to MP3 using FFmpeg Extract audio from each video by running the video_to_mp3 script. Step 3 – Convert MP3 to JSON using Whisper Transcribe the audio using the Whisper model and save the output as JSON files. Step 4 – Convert JSON to Vector Embeddings Use the bge-m3 embedding model with Ollama to convert transcripts into vector embeddings. The preprocess_json script converts the JSON data into a dataframe and stores it as a joblib file. Step 5 – Query Processing with the LLM When a user asks a question: The system loads the embeddings from the joblib file Retrieves the most relevant transcript segments Generates a contextual prompt Sends the prompt to Llama 3.2 via Ollama The AI returns the answer along with the relevant video reference I learned a lot while building this project, especially about RAG pipelines, embeddings, and building AI-powered learning tools. Feedback is welcome! 🚀 #AI #MachineLearning #RAG #GenerativeAI #Python #LLM #ArtificialIntelligence

🚨 This Python tool just made vector databases optional for RAG. It's called PageIndex. It reads documents the way you do. No embeddings. No chunking. No vector database needed. Here's the problem with normal RAG: It takes your document, cuts it into tiny pieces, turns those pieces into numbers, and searches for the closest match. But closest match doesn't mean best answer. PageIndex works completely different. → It reads your full document → Builds a tree structure like a table of contents → When you ask a question, the AI walks through that tree → It thinks step by step until it finds the exact right section Same way you'd find an answer in a textbook. You don't read every page. You check the chapters, pick the right one, and go straight to the answer. That's exactly what PageIndex teaches AI to do. Here's the wildest part: It scored 98.7% accuracy on FinanceBench. That's a test where AI answers real questions from SEC filings and earnings reports. Most traditional RAG systems can't touch that number. Works with PDFs, markdown, and even raw page images without OCR. 100% Open Source. MIT License.

🔧 Building AI Agents from Scratch – Part 3 is live! In Part 1, I shared why I started with Autogen and the realization that agents are loops of decision + execution. In Part 2, I built my first agent using LLM + tool calling and learned how control really works. Now in Part 3, I explore how agents can share Python tools using MCP (Model Context Protocol): ✨ Why tool sharing matters for agent collaboration ✨ How MCP provides a structured way to expose and reuse tools ✨ My experience wiring Python tools into agents with MCP ✨ Lessons learned about interoperability and clarity in agent design This series continues to be based entirely on my work experience. It’s not about frameworks—it’s about learning the fundamentals and understanding what they’re built on. 👉 Read Part 3: https://lnkd.in/ge_DzjtR If you’re curious about how agents can collaborate and share capabilities, I’d love for you to follow along. #AI #Agents #MCP #Python #AgenticAI #LearningByDoing

Why does Python store *args in a tuple instead of a list? When we define a function using *args, Python allows us to pass a variable number of positional arguments. Example: def check_type(*args): print(type(args)) check_type(1, 2, 3, 4) Output: <class 'tuple'> This confirms that *args stores the values in a tuple, not a list. All passed positional arguments are automatically packed into a tuple, and the variable args becomes a reference to that tuple. But why does Python choose a tuple instead of a list? There are two main reasons: 1️⃣ Immutability and Data Safety Tuples are immutable, meaning their contents cannot be modified after creation. Function arguments are generally expected to remain constant within the function’s scope. By storing them in an immutable structure, Python ensures that the original input values cannot be accidentally altered (e.g., appended, removed, or reordered). This design choice promotes safer and more predictable code while preserving data integrity. 2️⃣ Performance and Memory Efficiency Tuples are more memory-efficient and slightly faster than lists because they have a fixed size at creation. Lists, on the other hand, are dynamically resizable and may allocate extra memory to support future growth. Since most functions do not modify their input arguments, using a tuple provides better efficiency without affecting the required behavior. 🔹In summary: *args stores values in a tuple because tuples are immutable, safer, and more memory-efficient, making them the most appropriate structure for handling variable positional arguments. #Python #MachineLearning #SoftwareDevelopment #CodingTips #AI

🐍 In Python, one of the most powerful and flexible data structures is the List 📋 But what makes a List so special? 🤔 ✔ It is ordered ✔ It is changeable ✔ It allows duplicates ✔ It can store different data types You can: ➕ Add items ✏ Change items ❌ Remove items 🔄 Sort items 🔗 Join lists 📋 Copy lists Lists can do so many things… 👉 Why are they used everywhere in Data Science, AI, and Web Development? 🚀 Learn everything about: Indexing 📌, Slicing 🔢, append(), insert(), extend() ➕ remove(), pop(), del ❌, sort() 🔄, copy() 📋 📘 Read the full simple guide here: 👉https://lnkd.in/gWwQcax3