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.
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 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.
This article explains what JSON is, its language‑independent syntax, how to define objects, arrays and nested structures, and demonstrates practical ways to parse and manipulate JSON data using JavaScript and Python code examples.
This guide walks you through creating a versatile Python text replacement utility—covering simple string swaps, regex-based changes, dictionary mappings, batch file processing, sensitive‑word filtering, and HTML tag cleaning—to streamline everyday data processing and text‑cleaning workflows.
This article walks through the complete process of creating, testing, and publishing a streamable HTTP MCP server using the official MCP SDK, covering environment setup with Anaconda and uv, project structuring, code implementation, tool integration, Inspector testing, PyPI deployment, and client verification with CherryStudio.
This article introduces a curated list of lesser‑known Python packages for data‑science tasks—including Wget, Pendulum, imbalanced‑learn, FlashText, fuzzywuzzy, PyFlux, Ipyvolume, Dash, and Gym—providing installation commands, brief usage examples, and explanations of when each library is useful.
This article explores a common Python confusion by explaining why the built‑in function all applied to an empty tuple returns True, whereas any applied to the same empty tuple returns False, and provides step‑by‑step code analysis and visual explanations.
This guide explains how to use Python libraries such as pdf2docx, pdfplumber, python-docx, and Pillow to extract text, tables, and images from a PDF and reconstruct them in a Word document, including installation steps and a complete example script.
This guide presents nine practical Python debugging methods—including try‑except blocks, print statements, the pdb debugger, assertions, stack trace analysis, linting tools, IDE breakpoints, logging, and unit testing—to help developers quickly identify and resolve errors in their code.
This article explains Python iterables, covering their basic concepts, how to create and use them with loops, iter() and next(), built‑in functions that accept iterables, comprehension techniques, advanced operations like zip, enumerate, filter, map, and their relationship with generators for efficient data processing.
This guide outlines essential Locust load‑testing practices, covering resource and error handling, realistic user behavior simulation, distributed test setup, environment consistency, monitoring and reporting, security considerations, and systematic performance bottleneck identification.
Learn how FastAPI handles various response types—including default JSON, custom status codes and headers, HTMLResponse, FileResponse, StreamingResponse, and user‑defined response classes—while covering best practices, common pitfalls, and code examples for building robust APIs.
This guide explains FastAPI’s full application lifecycle—including startup initialization, middleware handling, request processing steps, background tasks, and graceful shutdown—so developers can design, debug, and deploy robust asynchronous APIs efficiently.
This article explores how to integrate the open‑source Qwen3‑235B‑A22B large model with Model Context Protocol (MCP) servers and ComfyUI, detailing architecture, Python implementation, deployment steps, third‑party media integration, practical use cases, limitations, and future prospects.
This article demystifies Principal Component Analysis by explaining its intuition, the role of variance, step‑by‑step visual analogies, the mathematical foundation, and a complete Python implementation using scikit‑learn, including data generation, scaling, fitting, scree plot visualization, component interpretation, and dimensionality reduction to two principal components.
This article explains how to use Locust's command‑line options, configure scripts with wait_time and task weighting, create custom clients, and apply advanced settings such as catch_response and lifecycle hooks to perform precise load testing of web applications.
Server‑Sent Events (SSE) provide a simple, one‑way server push mechanism over HTTP, ideal for real‑time updates such as dashboards, notifications, and data streams; this guide explains SSE fundamentals, compares alternatives, and walks through integrating SSE into FastAPI using the sse‑starlette library with full code examples.
This article explains the limitations of the original Stdio and HTTP SSE communication modes for MCP, introduces the Streamable HTTP protocol that resolves those issues, and provides a step‑by‑step Python implementation of both a Streamable HTTP MCP server and a matching client, complete with environment setup, FastAPI code, JSON‑RPC handling, and tool‑calling examples.
This article provides a thorough overview of Python's role in web development, covering core components, major frameworks like Django, Flask, and FastAPI, ecosystem tools, real-world case studies, learning paths, and future trends for building modern backend applications.
Discover five powerful Python command‑line utilities—httpie, glances, rich‑cli, howdoi, and csvkit—that streamline API interactions, system monitoring, output formatting, quick Stack Overflow answers, complete with installation steps and practical examples to boost your productivity.
This tutorial walks beginners through obtaining a DeepSeek API key, setting up an Alibaba Cloud ECS instance, configuring the server and WeChat public platform, installing required Python dependencies, editing configuration files, and finally running the chatbot so the public account can interact with the DeepSeek large‑language model.
Python generator functions, using the yield keyword, enable lazy evaluation and memory-efficient data processing, with examples covering basic syntax, differences from regular functions, Fibonacci sequence generation, large file reading, two-way communication via send(), and control methods like throw() and close(), highlighting their advantages.
FastAPI’s BackgroundTasks feature lets you register functions that run after a response is sent, enabling non‑blocking operations such as sending emails, logging, or cleaning resources, with simple code examples, parameter details, and insights into its Starlette‑based implementation and limitations.
This article provides a step‑by‑step guide on installing the openpyxl library, creating new Excel workbooks, reading existing files, applying common operations such as iterating cells, modifying values, styling, merging, freezing panes, adding formulas, adjusting dimensions, and demonstrates practical scenarios including bulk data writes and pandas integration.
This article explains why Python is a leading language for DevOps automation, detailing its core advantages, typical use cases such as bulk server management, configuration management, log analysis, and scheduled tasks, and introduces common Python libraries and learning pathways for building robust operational workflows.
The article explains how the Model Context Protocol (MCP) introduces Streamable HTTP as a modern, bidirectional transport that overcomes the one‑way, session‑less limitations of Server‑Sent Events, providing richer data formats, built‑in session management, and better resilience for AI assistants.
This article benchmarks Python 3.11's speed with a Monte Carlo Pi estimation script, compares it to earlier Python releases and a C++ implementation, shows Docker‑based testing methodology, presents performance results, and extrapolates when Python might surpass C++ in execution time.
The article first highlights Tencent's Q1 2025 financial results and user metrics, then introduces the LeetCode 2013 'Detect Squares' problem, describing its requirements, example, and offering Java, C++, Python, and array‑based solutions along with time and space complexity analysis.
This article explains why Python has become the leading language for data analysis and machine learning, outlines the essential libraries and frameworks, provides practical code examples, describes typical application scenarios, suggests a staged learning roadmap, and forecasts future trends such as AutoML and federated learning.
This article outlines Python's advantages for web crawling, introduces core libraries such as Requests, BeautifulSoup, and Scrapy, details a step-by-step development workflow, provides practical code examples for extracting news titles, and highlights important considerations and advanced techniques for robust scraper implementation.
This article introduces OpenAI’s CLIP multimodal model, explains its architecture and contrastive training, details hardware and installation steps, and demonstrates a hands‑on zero‑shot image classification workflow that achieves 97% confidence on a cat image without any task‑specific fine‑tuning.
This guide explains six essential Python import techniques—including using full module imports, aliases, selective imports, avoiding wildcard imports, checking existing names, and leveraging the __all__ attribute—to help you write clearer, conflict‑free code.
This article introduces ten highly practical Python libraries for data analysis—from Pandas and NumPy for data manipulation to Matplotlib, Seaborn, Plotly, Bokeh for visualization, and Scikit‑learn, Prophet, Dask, and PySpark for machine learning and big‑data processing—each illustrated with concise code snippets.
The article reviews the shortcomings of traditional large language models, explains how function calling extends LLMs beyond pure text, introduces the Model Context Protocol (MCP) as a standardized USB‑C‑like interface for AI tools, and demonstrates a Python MCP example that integrates LLMs with Tencent Advertising APIs.
This guide shows how to combine ELK, DeepSeek’s LLM API, and a Feishu chatbot in Python to automatically collect, analyze, classify, and alert on system logs, using a config file, custom utilities, and a simple historical fault database for intelligent DevOps monitoring.
This guide walks through creating a FastAPI application that both publishes and consumes messages via RabbitMQ, detailing the setup of a Pika client, asynchronous consumer, message handling, API routes, and deployment with uvicorn, complete with code snippets and testing instructions.
This article introduces beginner-friendly Python web‑scraping methods, covering the simplest urllib/requests approach, adding request headers, inspecting network traffic for hidden data, handling dynamically loaded content with Selenium, and provides links to deeper tutorials for each technique.
This article demonstrates how large language models can augment business development engineers by providing data insight, automating algorithm training, and enabling low‑cost rapid product prototyping, thereby transforming traditional backend‑focused roles into full‑stack, AI‑enhanced innovators.
This article explains why unit testing and debugging are essential in Python development, introduces the unittest and pytest frameworks, shows how to measure test coverage, demonstrates debugging methods like print statements, pdb, and IDE tools, and provides examples of integrating tests into CI pipelines.
This article introduces Pydantic (v2), explains its core validation, parsing, and serialization features, compares it with plain dataclasses, demonstrates basic to advanced usage—including optional fields, default factories, nested models, custom validators, and alias handling—while warning about version differences and AI‑generated code pitfalls.
This guide walks you through the fundamentals of creating a Python package, from setting up the directory and __init__.py file to adding modules, configuring setup.py, and using the package locally or via installation, complete with code examples.
This guide explains how FastAPI uses Pydantic models to define, validate, and parse JSON and form request bodies, set default values and custom rules, handle nested structures, and return response models, providing a type‑safe, efficient way to build backend APIs.
This article introduces Python's built‑in json module, explaining how to serialize Python objects to JSON strings and files, deserialize JSON back to Python, and demonstrates common tasks such as pretty‑printing, handling Unicode, working with lists and nested structures, custom encoders, and network responses.
This article introduces fifteen widely used open‑source Python frameworks—including Django, Flask, Tornado, Dpark, and Scrapy—covering web development, data analysis, asynchronous I/O, and distributed computing, and briefly describes each framework’s main features and typical use cases.
This tutorial demonstrates how to reverse‑engineer the X‑Product Android app, locate the dynamic newSign parameter, hook the RequestUtils.c method with Frida, and expose it via an RPC‑based FastAPI service to generate valid signed requests for the search API.
This article explains the difference between greedy and non‑greedy (lazy) matching in regular expressions, describes how quantifiers behave by default, shows how to switch to lazy mode using a trailing question mark, and provides multiple Python code examples illustrating both approaches.
This tutorial walks you through installing FastAPI, setting up a project structure, creating routes that serve Jinja2‑rendered HTML pages, adding static files, building forms, and mastering essential Jinja2 syntax such as variables, conditionals, loops, template inheritance, filters, macros, and security considerations.
This article presents ten useful Python automation scripts that demonstrate how to read, compare, filter, merge, re‑encode, extract, count, report, replace, and selectively retrieve lines from text files, helping both developers and everyday users boost productivity.
This article explains how to monitor the /Volumes directory on macOS to detect USB insertion, then uses Python's os, shutil, and re modules to recursively walk the USB file system, filter files by type, size, and modification time, and automatically copy selected files to a local folder.
This tutorial walks through building a Retrieval‑Augmented Generation (RAG) system by combining LangChain for document processing, Elasticsearch’s vector store with the ELSER v2 model for semantic search, and Higress as a cloud‑native AI gateway, complete with deployment scripts, code examples, and query testing.
NVIDIA announced native Python support in its CUDA toolkit, enabling developers to write GPU‑accelerated code directly in Python, detailing the new programming model, JIT‑based architecture, performance benefits, and the broader impact on AI development and the developer ecosystem.
This article explains how large language models combined with Python's data‑science ecosystem can automate metadata extraction, data cleaning, and analysis tasks—illustrated with a step‑by‑step Titanic passenger dataset case study, complete prompts, code snippets, and best‑practice recommendations.
The updated MCP protocol (2025‑03‑26) introduces JSON‑RPC batch processing and enhanced tool annotations, enabling AI agents to send multiple requests in a single call, improve performance, and provide richer metadata for safer, more transparent tool usage.
Learn how to design robust exception handling for FastAPI applications by combining Look‑Before‑You‑Leap and EAFP strategies, creating custom exception classes, organizing handlers, and integrating them into your API to improve maintainability, clarity, and error response consistency.
This tutorial walks you through registering on OpenAI, installing required Python packages, setting up API keys, and writing a Jupyter Notebook that defines a chat function and an interactive loop to create a functional GPT‑3.5 chatbot.
This article introduces Python's Matplotlib and Seaborn libraries for data visualization, covering basic and advanced statistical charts, common plot types, customization techniques, and multi‑plot layouts with clear code examples and a comparative summary of each library's strengths.
Python 3.14 adds the PEP 750 T‑string syntax to address security risks in existing string formatting methods like f‑strings, offering a template‑based approach that enables safer handling of user input, SQL queries, and HTML rendering.
This tutorial walks through registering a Qwen3 API key, setting up Qwen‑Agent, creating a multi‑turn chatbot, and integrating the MCP SQLite tool to enable natural‑language driven database operations, complete with step‑by‑step code examples and screenshots.
This article provides a comprehensive collection of Python code snippets demonstrating how to obtain, format, convert, calculate differences, and perform various operations with dates and times, including timers, scheduling, and weekday handling.
This article walks through the design and full implementation of an Agentic Retrieval‑Augmented Generation (RAG) system built on the MCP standard, covering the conceptual fusion of MCP and RAG, server‑side tool creation with LlamaIndex, client‑side agent construction with LangGraph, configuration files, caching strategies, code examples, and an end‑to‑end demonstration.
The article explains why defining custom __init__ methods for simple data structures is a bad practice in Python and proposes a modern solution using dataclasses, classmethod factories, and typing.NewType to create clear, testable, and type‑safe class interfaces.
This guide explains how to create a lightweight, extensible Alibaba Cloud OpenAPI MCP Server using only ten lines of Python, covering MCP fundamentals, tool registration via OpenAPI metadata, configuration, code examples, and client setup to enable seamless LLM integration with external services.
This article demonstrates how to employ Frida's RPC forwarding to intercept and bypass encryption in a mobile app, providing step‑by‑step environment setup, hook scripts, and a FastAPI service that enables Python‑based crawling of protected API endpoints.
This article introduces uv, a Rust‑based Python package manager, and demonstrates how to initialize a project with uv init, add dependencies with uv add, manage virtual environments via uv venv, and run tools with uvx, offering a faster, more automated alternative to pip and requirements files.
This article presents a thorough set of Python decorator implementations covering logging, performance timing, exception handling, caching, retry mechanisms, authentication, parameter validation, decorator chaining, JSON response formatting, rate limiting, environment variable injection, response monitoring, custom headers, data transformation, concurrency control, distributed locking, API version control, security auditing, input validation, and output filtering, each with usage examples and sample output.
Learn how to safeguard your Python applications by avoiding hard‑coded secrets, using .env files, employing virtual environments, validating and sanitizing inputs, handling files securely, encrypting sensitive data, and implementing proper exception handling—all essential steps for robust information security.
This tutorial introduces Pandas as a core Python library for data processing, demonstrates environment setup, shows how to create and manipulate Series and DataFrames, performs data aggregation and grouping on the Iris dataset, and visualizes results using Matplotlib with extensive code examples.
This tutorial explains how to bridge Python with Prometheus using the prometheus_api_client library, fetch time‑series metrics, process the data with pandas, and create insightful visualizations with Plotly, illustrating a complete workflow from data collection to presentation.
Learn how Python can interact with the three major API types—SOAP, REST, and GraphQL—by understanding their core concepts, differences, and practical code examples using libraries like zeep and requests, empowering you to build robust integrations across diverse services.
This article explains how vector embeddings enhance Elasticsearch for semantic search and recommendation, walks through the complete workflow of generating, storing, and querying embeddings, and provides detailed Python and Logstash implementations with code samples, pros and cons, and guidance on choosing the right approach.
This guide walks through setting up RabbitMQ via Docker, configuring Celery with FastAPI, defining asynchronous tasks, launching workers, testing endpoints, and monitoring execution with Flower, providing a complete, step‑by‑step solution for background processing in Python web applications.
This article provides a thorough overview of NumPy, covering its core ndarray structure, various array creation methods, indexing and slicing techniques, vectorized operations with broadcasting, statistical and linear‑algebra functions, file input/output, and a practical data‑analysis example, all illustrated with executable Python code.
This article walks through a common Python matplotlib visualization issue, showing how to read parameter data, generate multiple gamma distribution curves, add labels and legends, and produce polished plots, with complete code examples and explanations to help readers replicate the solution.
This tutorial explains the Model Context Protocol (MCP) for integrating large language models with external data sources, details its architecture, connection lifecycle, and core JSON‑RPC features, and provides a step‑by‑step Python implementation that fetches real‑time tech news and integrates with Claude Desktop.
Explore how Python’s built-in __dict__ attribute stores object attributes, enabling introspection, dynamic attribute manipulation, memoization, JSON serialization, custom descriptors, and debugging, while also learning its limitations with slots and built-in types for performance.
