This article explains how to create a reusable Python decorator that automatically retries a function a configurable number of times, supports custom exception types and delays, preserves the original function's metadata, and optionally logs each attempt with adjustable log levels.
This guide shows how to replace limited IAM Identity Center access by creating a lightweight, MFA‑protected CLI login portal using AWS Cognito user pools and identity pools, generating temporary STS credentials and automating the process with a Python/Boto3 script.
This article explores NumPy arrays' internal memory layout, data structures, and design choices—covering contiguous storage, strides, C/F contiguous layouts, views versus copies, and powerful indexing and slicing techniques—to reveal why they are dramatically faster than Python lists.
This tutorial walks through the limitations of linear LangChain workflows, introduces LangGraph’s state‑node‑edge architecture, and provides step‑by‑step code examples—including a Hello‑World tool, conditional branching, multi‑turn conversation handling, and graph visualization—so readers can construct robust, persistent LLM agents.
This article explains Python decorators—functions that return functions—to decouple logic, improve reusability, and extend behavior without modifying original code, covering basic syntax, parameterized and nested decorators, functools utilities, built‑in decorators, and practical examples like logging, timing, permission checks, and caching.
Python’s open‑source ecosystem, extensive libraries, and low learning curve are rapidly displacing MATLAB in academic research, industry, and AI development, as universities adopt Python curricula, companies integrate it for data analysis and modeling, while MATLAB retains niche strengths in Simulink and specialized engineering toolboxes.
This article walks through the mechanics of greedy search and beam search in large language models, demonstrates both methods with GPT‑2 on the prompt "I have a dream", visualizes the decoding trees, compares their scores, and discusses the trade‑offs between efficiency and output quality.
Discover a curated list of essential Python libraries—including Python‑Dotenv, Django Ninja, Pydantic, Python‑Social‑Auth, HTMX, Cotton, Faker, and Systemd—that enhance Django development by improving configuration, API creation, form handling, authentication, front‑end interactivity, component reuse, test data generation, and logging.
Discover ten powerful Python techniques—from using any() and all() to streamline loops, to leveraging the walrus operator, set operations, and defaultdicts—that make your code more concise, faster, and aligned with Pythonic best practices.
This tutorial walks you through creating a simple 'Eat Coins' game using Python's Pygame library, covering OOP design, class implementation for player, coin, and game management, game loop handling, collision detection, scoring, visual enhancements, and extension ideas.
The article first reflects on ByteDance's expanding English testing policy, then presents LeetCode problem 799 “Champagne Tower”, describing its mechanics and offering a linear‑DP solution with full implementations in Java, C++, Python and TypeScript, along with complexity analysis.
This tutorial walks through Python-based computer‑vision techniques—including XOR‑based image encryption, mask and ROI methods, digital watermark embedding via bit‑plane and LSB, sensitivity‑driven object detection, and HSV‑based green‑screen removal—providing complete code snippets and practical guidance for rapid AI‑assisted learning.
This article explains the differences and uses of instance variables, class variables, instance methods, class methods, and static methods in Python, illustrating each concept with a Dog class example and providing code snippets to help developers write clearer, more maintainable object‑oriented code.
This article details how to create a Python‑based weather data analysis and visualization platform using Flask for the backend, PyEcharts for interactive charts, and web scraping to fetch live meteorological data, covering architecture, core features, and deployment steps.
Learn how to install and use the Hypothesis library for Python to perform property‑based testing, automatically generating diverse inputs, covering edge cases, and enhancing test coverage with examples on arithmetic properties, list sorting, custom strategies, settings, and real‑world scenarios like JSON and URL validation.
This article introduces the Model Context Protocol (MCP), explains its core advantages such as capability expansion, standardized interfaces, and low‑code integration, and demonstrates a practical Sentry‑MCP implementation with Python code, detailed functions, and visual results for AI‑driven data access.
The article provides a detailed walkthrough of OpenManus, an open‑source AI agent framework built with Python 3.12, covering its modular architecture, agent and tool hierarchies, a step‑by‑step usage example for generating a Beijing travel plan, and a deployment guide on Alibaba Cloud.
This article explains why Chinese characters appear as garbled text in Jupyter notebooks and VS Code, demonstrates the issue with screenshots, evaluates several Python code fixes, and ultimately provides a reliable solution by setting the console code page to UTF‑8.
This article explains how to combine Alibaba Cloud's MCP Server with large language models to enable natural‑language operations on cloud products, covering setup, tool selection, OAuth authentication, code examples, troubleshooting context‑length limits, and future enhancements for more efficient, secure cloud management.
The article explains the mathematical definition of cosine similarity, how large language models use it to compare vector directions, its key characteristics and importance for AI retrieval and generation, and includes a simple Python example using SentenceTransformer.
This article walks through a Python function‑argument issue, explains how default parameters work, shows the code breakdown with visual diagrams, and demonstrates how to use Python Tutor to visualize execution, helping readers solve similar problems and deepen their understanding of Python functions.
Learn how to create a fully functional Python calculator using Tkinter, covering complete requirements, UI design, button layout, advanced math operations, dynamic font scaling, keyboard handling, and extensibility suggestions, with the entire source code and detailed explanations for each component.
This article explains what immutable objects are in Python, shows how they behave when passed as function arguments through clear code examples with integers, strings, and tuples, and offers practical advice on using immutable versus mutable types to avoid unintended side effects.
This guide walks through ten Python function‑argument examples—including positional, keyword, default values, mutable‑default pitfalls, variable‑length *args and **kwargs, argument unpacking, ordering rules, and mutable‑object handling—providing clear code snippets and explanations for each case.
This article explains how to decide between asyncio, threading, and multiprocessing for Python programs by examining I/O‑bound versus CPU‑bound workloads, showing real code examples, trade‑offs, and common pitfalls to help you pick the right concurrency tool for your task.
This article walks through a follower's Pyecharts map visualization problem, explains why the original code failed, and provides a corrected Python script that successfully renders COVID‑19 data maps, complete with screenshots and full code examples.
This tutorial demonstrates how to quickly create common 1‑D barcodes like Code 128 and EAN‑13, as well as QR codes, using the Spire.Barcode library in Python, including installation, key classes, and complete code examples.
This article explains how Python actually creates objects, clarifying the distinct roles of the __new__ and __init__ methods, and demonstrates practical techniques such as inheriting immutable types, adding metadata, and implementing singleton patterns through custom object creation.
This article explains how active learning can dramatically reduce the amount of labeled data required for training deep neural networks by selecting the most informative and representative samples, and provides a complete Python implementation of a hybrid query strategy (DBAL) with ResNet‑18.
This guide walks you through installing dependencies, creating two MCP‑based SSE servers and a client in Python, explains MCP concepts and architecture, and shows how to run the demo to explore the Model Context Protocol for AI agents.
This guide introduces the Model Context Protocol (MCP), explains its purpose as a standardized USB‑C‑like interface for LLMs, and provides step‑by‑step Python code to set up SSE‑based MCP servers and a client, plus essential installation details and execution commands.
Profiling lets you pinpoint performance bottlenecks in Python code by measuring function execution times, call counts, and line‑by‑line costs, with tools like cProfile for quick overviews and line_profiler for detailed per‑line analysis, plus tips, visualizers, and complementary utilities to optimize scripts efficiently.
This article walks through uploading a MiniLM model to the Modelers.cn community, explains why testing is essential, demonstrates both usability and local tests with openMind, and provides complete Python code for classification and simple question‑answering, enabling developers to quickly deploy and evaluate MiniLM in practice.
This article explains the history and drawbacks of Python’s Global Interpreter Lock, introduces PEP 703’s optional no‑GIL build, provides step‑by‑step installation instructions, showcases performance benchmarks, and discusses the impact on developers and the Python community.
This guide shows how to install Gradio with MCP support, write a few lines of Python to expose a function as an MCP tool, launch the server, and integrate it with large language model clients such as Claude Desktop or Hugging Face Spaces.
This tutorial shows how to install LangGraph and MCP Server, define math and weather tool nodes, connect them via a MultiServerMCPClient, and build a ReAct agent that demonstrates tool‑calling workflows, including handling missing functions and HTTP‑based services.
The June 2025 TIOBE index shows Python reclaiming the top spot with a 10.5% surge, while Java falls to fourth, prompting analysis of AI-driven growth for Python, the enduring relevance of C/C++ in systems and game development, and the stable enterprise value of Java.
This tutorial walks you through building a digit classifier using PyTorch and the MNIST dataset, covering environment setup, data loading, model construction, training, evaluation, and model persistence while explaining core deep‑learning concepts.
Guido van Rossum recounts Python’s humble origins, explains how the ‘Worse is Better’ philosophy drove its rapid early adoption, examines its lasting impact on language design, and debates whether this pragmatic approach remains relevant today, even as Python integrates with Rust and evolves.
This article walks through deploying the high‑performance vLLM LLM inference framework, covering GPU and CPU backend installation, environment setup, offline and online serving, API usage, and a performance comparison that highlights the ten‑fold speed advantage of GPU over CPU.
This article presents a step‑by‑step guide for constructing a scalable enterprise Retrieval‑Augmented Generation (RAG) solution using the Model Context Protocol (MCP), covering architecture comparison, system design, Milvus‑backed knowledge store, Python client implementation, deployment scripts, code examples, and best‑practice recommendations.
This guide walks through installing the schedule package, demonstrates basic and advanced usage such as setting various time intervals, canceling jobs, running multiple tasks, limiting executions, adding tags, and handling errors, all with clear Python code examples.
This tutorial walks you through creating a basic match‑3 puzzle game similar to Candy Crush using Python and Pygame, covering setup, grid rendering, random gem placement, scoring, timing, match detection, gem swapping, and game‑over logic with complete code snippets.
This tutorial demonstrates how to import, clean, and explore 2013 weather observations from Toulouse Airport using Python libraries such as pandas and SciPy, perform consistency checks, visualize temperature trends, assess variable correlations, and fit probability distributions—including normal, log‑normal, and Weibull—to the data.
This tutorial explains how to change mouse cursor shapes in PyQt5, covering built‑in Qt cursor constants, practical code examples for setting default and hand cursors, and step‑by‑step guidance for creating fully custom cursors using QPixmap and QCursor.
This article explains how FastAPI middleware sits between incoming requests and outgoing responses, detailing built‑in and third‑party middleware such as CORS, GZip, HTTPS redirect, session, trusted host, error handling, rate limiting, authentication, custom headers, logging, timeout, trailing‑slash handling, IP whitelisting, proxy headers, CSRF protection, context management and global state, each with usage scenarios and code examples.
Learn how to fully remove Python from a Windows system by following detailed steps—including using the installer’s uninstall option, Windows Settings, manual deletion of installation folders, cleaning environment variables, and clearing related AppData and pip caches—to ensure no residual files remain.
Learn how Python’s @dataclass decorator, introduced in Python 3.7, streamlines class definition by automatically generating constructors, string representations, and more, while covering default values, mutable defaults handling, field exclusion, read‑only classes, and conversion to tuples and dictionaries for efficient data handling.
This guide explores six practical Python techniques for merging two lists—including the + operator, extend(), zip(), unpacking, list comprehensions, and itertools.chain()—detailing code examples, performance considerations, and when to choose each method for efficient data handling.
This article explains Python's @ operator for matrix multiplication, shows basic usage with NumPy, contrasts it with element‑wise *, demonstrates matrix‑vector multiplication, highlights common dimension‑mismatch errors, and provides a concise summary for efficient linear‑algebra calculations.
This article provides a comprehensive overview of web‑scraping technologies, compares popular tools such as requests, BeautifulSoup and Selenium, introduces AI‑assisted crawling with DeepSeek, and walks through practical steps for using BrightData’s platform to collect industry data, complete with ready‑to‑run Python code.
This article outlines the standard BCC workflow for creating eBPF tools, then dissects the opensnoop source code, covering requirement analysis, kernel‑space program writing, BPF map configuration, user‑space Python integration, argument handling, testing, optimization, and deployment steps to monitor open system calls.
This tutorial explains how to integrate Redis caching into a FastAPI application, covering installation, connection handling, cache expiration, testing, cache clearing, and best‑practice considerations to dramatically improve API response times and scalability.
This article introduces a curated collection of Python’s most useful built‑in functions and standard‑library modules—including all, any, argparse, Counter, defaultdict, dataclass, datetime, lru_cache, itertools.chain, json, pickle, pprint, re, timeit, and uuid—explaining their purpose, providing clear usage examples, and highlighting practical scenarios where they simplify everyday coding tasks.
This tutorial walks you through building a Python web‑scraper for Beike (Lianjia) second‑hand property listings, covering session spoofing, dynamic parameters, pagination, multithreaded detail fetching, data cleaning, and exporting results to Excel in a step‑by‑step manner.
This deep‑dive explains how Ray Data transforms user‑level Dataset APIs into a logical plan, optimizes it, converts it into a physical streaming execution graph, and runs it on a cluster using task and actor pools, detailing each component from read sources to write sinks with code examples.
Learn how to create fast, modern Python APIs using FastAPI, automatically generate interactive Swagger documentation, and enhance your endpoints with validation, metadata, and a full-featured to‑do list project, all illustrated with clear code examples and step‑by‑step deployment instructions.
This step‑by‑step tutorial walks beginners through creating a new Python project in PyCharm, covering project location selection, Conda interpreter configuration, isolated environment creation, Python version choice, Conda executable setup, opening the project, exploring the directory structure, writing and running a simple program, and where to download the free Community edition.
This article demystifies Python’s a, b = b, a idiom by detailing how tuple packing and unpacking work, the exact evaluation order, the CPython bytecode implementation, comparisons with C, C++, Java, JavaScript, and the performance and memory implications of the technique.
Server‑Sent Events (SSE) offer a lightweight, HTTP‑native solution for real‑time, one‑way streaming, making them ideal for AI chat applications that need a typewriter‑style response, with advantages over WebSockets such as easy implementation, automatic reconnection, broad compatibility, and simple debugging.
This tutorial walks you through creating a compact Python Tkinter GUI that can send GET/POST requests, handle JSON or XML payloads, support Bearer tokens, clean illegal URL characters, and be packaged into a standalone Windows executable using PyInstaller.
Learn how to efficiently scrape web pages using Python by exploring multiple approaches—including simple requests with BeautifulSoup, fast parsing with lxml, dynamic content extraction with Selenium, and large‑scale crawling with Scrapy—complete with installation steps, code snippets, and detailed explanations.
Choosing the right programming language depends on project requirements such as performance, development speed, platform compatibility, and team expertise, with C++ excelling in low‑level control, Java dominating enterprise back‑ends, Python leading in AI and rapid development, and C# powering Windows and Unity game applications.
Within just 30 minutes, this guide walks beginners through Python’s core syntax—including variables, data types, operators, control flow, functions, and essential data structures—providing clear explanations and runnable code examples so you can write your first programs and build a solid foundation.
This guide walks through the complete process of creating a RAG‑powered question‑answering bot using LangChain, Streamlit, and vector‑store embeddings, covering theory, architecture, data loading, chunking, vector indexing, retrieval, LLM integration, and full code implementation with practical examples.
This guide explains what comments are in Python, shows how to write single‑line and multi‑line comments using the # symbol, warns against misuse of triple quotes, covers docstring usage, and provides IDE shortcut keys for efficient commenting.
Explore the Python functools module’s most useful utilities—including reduce, partial, lru_cache, wraps, total_ordering, cmp_to_key, singledispatch, and cache—through clear explanations and practical code examples that demonstrate how each tool can simplify functional programming and improve code efficiency.
This guide introduces Python's core fundamentals, covering its concise syntax, commenting styles, dynamic variables, primary data types, input/output functions, a full range of operators, control‑flow statements, and essential data structures such as lists, tuples, dictionaries and sets, complete with examples and visual illustrations.
Optimizing Python is challenging due to its dynamic nature, but various strategies—from using NumPy, Numba, and Cython to upcoming CPython enhancements like adaptive specialization, JIT, and GIL‑free versions—show promise for improving performance while preserving the language’s flexibility.
Learn what higher-order functions are in Python, how they can accept or return other functions, explore built-in examples like map, filter, sorted, reduce, and see custom implementations and lambda integrations through clear code snippets and practical usage tips.
Python 3.14 brings a collection of major upgrades—t‑strings for safer templating, lazy type‑annotation evaluation, a standardized external debugger API, built‑in Zstandard compression, a smarter REPL, new UUID versions with 40% faster generation, and stricter finally‑block semantics—each aimed at improving developer productivity, security, and runtime performance.
This article introduces the OpenAI Agents SDK, explains its key capabilities such as Agent Loop, Handoffs, Guardrails, and Tracing, provides practical Python code examples, compares it with other multi‑agent frameworks, and discusses best practices for building reliable AI applications.
Learn why organizing Python code with functions, modules, and packages is essential for maintainable, scalable projects, and follow step‑by‑step examples that cover basic syntax, practical tips, package structures, dynamic imports, and a hands‑on mini‑project to build your own utility toolkit.
This tutorial explains how to use Python to scrape product reviews from JD.com via its AJAX comment API, extract fields such as nickname, score, content, and image count, and save the collected data into a CSV file using the requests and csv modules.
This article walks through using Pandas to directly read HTML pages, extract table data, handle AJAX‑loaded JSON and CSV formats, and save results, providing concise code examples and visual steps for effective Python web scraping and data mining.
This article explains various Selenium waiting techniques—including implicit wait, fixed (hard) wait, page load strategies, and JavaScript detection—detailing their principles, advantages, disadvantages, and providing Python code examples to help choose the most suitable approach for stable and efficient automated web testing.
Explore ten crucial Python design patterns—from Singleton to Memoization—complete with real-world examples for data pipelines, ETL processes, and scalable systems, helping developers write cleaner, more maintainable, and efficient code across backend and data engineering tasks.
This article introduces a Python‑based GUI application that formats, compares, and highlights differences between two JSON files, detailing its features, implementation using tkinter, json and DeepDiff, example usage, and instructions for running and extending the tool.
Tencent’s HunyuanVideo-Avatar converts a static portrait and an audio clip into a lip‑synced, expressive video using a multimodal diffusion Transformer, offering open‑source weights, detailed module designs, hardware requirements, code examples, and a candid assessment of its strengths and current limitations.
This article explains Python's built‑in sorting functions, demonstrates when to use sort() versus sorted(), shows how to implement custom key functions and multi‑level sorting, and describes the efficient Timsort algorithm behind them.
This article presents the LeetCode 764 problem of finding the largest axis‑aligned plus sign in a binary grid, explains the preprocessing and simulation approach using four directional prefix arrays, analyzes time and space complexity, and provides complete Java, C++, Python, and TypeScript implementations.
Learn how to quickly create downloadable, professionally styled PDF invoices using FastAPI and the xhtml2pdf library, covering prerequisites, FastAPI setup, HTML template design, PDF rendering, and server launch, plus tips for dynamic data, alternative tools, and security considerations.
The article explains what zero‑width Unicode characters are, lists common types, describes their applications such as steganography and text formatting, and provides Python code examples for inserting, hiding, extracting, bypassing filters, and removing these invisible characters.
This article explains why FastAPI struggles with CPU‑intensive tasks due to Python’s Global Interpreter Lock, describes the types of workloads affected, and provides concrete solutions such as background task queues, microservices, ProcessPoolExecutor, and C/C++ extensions to keep APIs responsive and scalable.
This guide walks through installing HttpRunner and Locust, creating a simple YAML test case, converting it to a Locust script, running load tests, customizing behavior, and analyzing performance metrics to evaluate API reliability under load.
This tutorial walks through why Multi‑Agent Systems, Anthropic's MCP and Google's A2A protocol are crucial for Agentic AI, then demonstrates how to set up two MCP servers, create a hierarchical trio of agents, enable inter‑agent coordination via A2A, and run the complete pipeline with detailed Python code and deployment tips.
This article explains why matching Python and Pandas versions is essential, provides a compatibility table, shows how to install the correct Pandas release for a given Python version, demonstrates checking current versions, and offers commands for upgrading or downgrading Pandas while recommending virtual environments and official documentation.
This guide explains how to set up and run Locust load tests for WebSocket connections and Redis interactions in Python, including client implementations, heartbeat simulation, and practical tips for resource management and concurrency control.
This guide demonstrates how to create a Python script that uses the win32com library to batch convert Word (.doc/.docx) files to PDF on Windows, including code examples, handling of Office/WPS detection, folder management, common pitfalls, and packaging the script into an executable.
This article explains how to construct a financial question‑answering agent that automatically decides between SQL queries and RAG retrieval, covering intent recognition, tool creation, prompt design, agent initialization, and end‑to‑end testing with Python code.
This article walks through a step‑by‑step evolution of backend configuration management—from hard‑coded constants to modular config files, environment‑specific .env files, Pydantic‑validated models, and finally YAML‑based settings—demonstrating how to build a clean, secure, and scalable setup for FastAPI applications.
This tutorial walks through creating a simple bigram language model in pure Python, refactoring it into a PyTorch implementation, and explains core concepts such as tokenization, embedding layers, loss functions, gradient descent, training loops, and text generation, preparing you for building a full GPT model.
Model Context Protocol (MCP) is an open standard that creates secure bidirectional links between data sources and AI tools, offering ecosystem plugins, cross‑model compatibility, and data‑privacy benefits; the article compares MCP with function calls and agents, outlines its architecture, and demonstrates practical implementations at Huolala.
This article walks through using LLaMA‑Factory—a unified framework that supports over 100 LLMs—to install dependencies, prepare Alpaca‑style datasets, perform LoRA fine‑tuning, run inference, and export the tuned model, all with concrete command‑line examples.
This article presents sixteen ready‑to‑use Python pandas examples that cover common Excel tasks such as reading, writing, sheet selection, cleaning, filtering, aggregation, styling, and exporting, providing a concise toolbox for data‑analysis automation.
This article provides a structured overview of Python version management, virtual environment handling, package management, building, and publishing tools, comparing utilities like pyenv, conda, pipenv, Poetry, pdm, Hatch, and Rye, and includes practical command examples and a feature‑comparison table.
This article examines ten frequent Python anti‑patterns—such as mutable default arguments, catching broad exceptions, overly long functions, reinventing the wheel, misusing list comprehensions, excessive lambdas, hard‑coded values, ignoring virtual environments, overusing inheritance, and neglecting code formatting—explaining why they harm readability, maintainability or performance and offering clear, better‑practice alternatives.
This article explains what Python's functools.partial is, shows its basic syntax, outlines its advantages such as reducing code duplication and improving readability, and provides multiple practical code examples—including simple addition, keyword arguments, complex use cases, comparisons with lambda, and real‑world applications in GUI and multithreading contexts.
This article explains what Python closures are, how they capture surrounding variables, their key characteristics, and demonstrates multiple practical patterns—including decorators, memoization, and factories—through clear code examples and usage guidelines.
This guide explains how to define Python functions, the role of return statements, differences between positional and keyword arguments, default‑parameter pitfalls, *args/**kwargs usage, argument unpacking, reference passing semantics, positional‑only/keyword‑only parameters, and anonymous lambda functions, all with clear code examples.
