AScript.Lang.Python3 is a C#-based Python 3 scripting extension that enables the AScript dynamic execution engine to run core Python 3 syntax. It addresses dynamic script embedding, multi-language extensibility, and runtime evaluation in .NET applications. Keywords: AScript, Python 3, C# scripting engine.
The technical specification snapshot provides a quick overview
| Parameter | Information |
|---|---|
| Project Name | AScript.Lang.Python3 |
| Positioning | Python 3 language extension for AScript |
| Core Language | C# |
| Runtime Environment | .NET / AScript |
| Installation Method | NuGet install-package |
| Current Version | 0.0.1 |
| Release Date | 2026-05-04 |
| Stars | Not provided in the source |
| License | Not provided in the source |
| Core Dependencies | AScript, AScript.Lang.Python3 |
| Open Source Repository | https://gitee.com/rockey627/AScript |
This extension gives AScript basic Python 3 execution support
AScript is an open-source dynamic scripting parse-and-execute engine written in C#. Its core value lies in its ability to support multiple scripting languages through extensibility. The release of AScript.Lang.Python3 0.0.1 means developers can now execute Python 3-style scripts directly inside existing .NET applications.
Its current feature set focuses on foundational syntax, including int, float, bool, str, list, set, and dict, along with common language features such as function definitions, collection operations, loops, lambda expressions, and type annotations.
The installation process is straightforward
install-package AScript
install-package AScript.Lang.Python3These two commands install the scripting runtime core and the Python 3 language extension, respectively.
The language registration model determines how Python 3 connects to the host engine
In AScript, a language is not enabled implicitly. Instead, you mount it explicitly through the registry. This design creates clear language boundaries and works well in enterprise host environments where multiple scripting languages may coexist.
// Register the python3 language instance
Script.Langs.Set("python3", Python3Lang.Instance);
// Enable setDefault if you want to make it the global default language
// Script.Langs.Set("python3", Python3Lang.Instance, setDefault: true);This code completes language loading and determines whether subsequent scripts can be recognized by the Python 3 parser.
Specifying the language in the context is better for isolated execution
If you do not want to affect the global default configuration, you can specify the allowed languages at the Script instance level. This approach is well suited for testing, sandboxing, and tenant isolation scenarios.
var script = new Script();
script.Context.Langs = new[] { "python3" }; // Only allow python3
var s = @"
def sum(a,b):
return a+b // Core logic: return the sum of two arguments
sum(10,20)
";
Assert.AreEqual(30L, script.Eval(s));This example shows that AScript can already handle basic function definition and evaluation.
Cross-language embedding is one of the most distinctive capabilities of this approach
The original article demonstrates the @lang and @end block syntax, which means a single script can mix C# and Python 3. For systems that need to combine host logic with dynamic rules, this capability is especially practical.
var s = @"
int mult(int a, int b) => a*b; // C# function
@lang python3
def sum(a,b):
return a+b // Core logic: perform addition inside the Python3 block
@end
int m = 10;
int n = 20;
mult(m, n) + sum(m, n)
";
var script = new Script();
Assert.AreEqual(230, script.Eval(s));This code shows that AScript does more than just “run Python.” It organizes multi-language collaboration inside a unified execution framework.
String support already covers interpolation, indexing, and slicing
Common Python 3 string features are already available, including f-strings, positive indexing, negative indexing, and slicing. These capabilities are important for template generation, rule expressions, and lightweight text processing.
var script = new Script();
script.Context.Langs = new[] { "python3" };
Assert.AreEqual("hello tom, 5+8=13", script.Eval(@"
name='tom'
f'hello {name}, 5+8={5+8}' // Core logic: use string interpolation
"));
Assert.AreEqual("ell", script.Eval("'hello'[1:4]")); // Core logic: extract a sliceThis indicates that the extension already delivers a fairly natural Python 3 authoring experience.
Collection type support determines whether scripts can handle real business rules
Based on the examples, list, set, and dict have already been mapped to common .NET container types. This is not just a syntax demonstration. It can return runtime results back to the host program in a stable way.
var script = new Script();
script.Context.Langs = new[] { "python3" };
var list = script.Eval<List<object>>(@"
list1 = [1,2,3]
list2 = [3,4,5]
list1 + list2 // Core logic: merge two lists
");
var dict = script.Eval<Dictionary<object, object>>(@"
p = {'name': '张三', 'age': 18}
p['age'] = 20 // Core logic: update a dictionary field
p
");This code demonstrates the bridge between script values and host objects, which is foundational for implementing rule engines in production.
Loops, comprehensions, and lambda already cover most lightweight computation needs
The released version also supports for in, enumerate, list comprehensions, and lambda expressions. For scenarios such as configuration-based computation, data transformation, and form rules, this level of coverage is already practical.
var script = new Script();
script.Context.Langs = new[] { "python3" };
Assert.AreEqual(6L, script.Eval(@"
total = 0
for x in [1, 2, 3]:
total += x // Core logic: accumulate values in a loop
total
"));
var result = script.Eval(@"[x * 2 for x in [1, 2, 3]]"); // Core logic: list comprehensionThis shows that the extension can already handle more than simple expressions. It can support small but meaningful scripting logic.
The current version is better suited to rule execution and embedded scripting scenarios
Based on its capability boundaries, version 0.0.1 is closer to a “basic Python 3 subset.” It fits embedding into business systems for expression evaluation, dynamic rules, plugin logic, and DSL augmentation, rather than replacing a full Python runtime.
If your goal is to introduce a low-cost, multi-language, controllable scripting layer into .NET, this extension is worth watching. For teams already using AScript in particular, it offers a more approachable Python 3 authoring experience than custom expression syntax.
The image adds source attribution and article sharing context
AI Visual Insight: This image is an animated WeChat sharing prompt from the blog page. It guides users to share the article through the top-right interaction menu. It does not contain details about the scripting engine architecture, execution flow, or language design, so its technical information density is low.
The FAQ provides structured answers
Q1: Does AScript.Lang.Python3 support full Python 3 today?
No. Based on the source content, the current version mainly covers core syntax, basic data types, functions, loops, lambda expressions, comprehensions, and type annotations. It is better understood as an embeddable Python 3 subset for business systems.
Q2: How is it different from integrating a Python interpreter directly?
It runs inside the AScript framework and focuses on unified integration with the C# host, controlled registration, mixed-language scripting, and result handoff, rather than providing a complete standalone Python runtime.
Q3: Which .NET scenarios are the best fit?
It is well suited for rule engines, dynamic expressions, configuration-driven scripts, low-code plugins, approval formulas, data transformation, and other business scenarios that need runtime-extensible logic while keeping the host environment under control.
Core summary helps .NET developers evaluate fit and limitations
This article reconstructs the release information for AScript.Lang.Python3 and systematically explains its language registration model, cross-language embedding, data structure support, and loop capabilities inside a C# dynamic scripting engine. It helps .NET developers quickly evaluate the extension’s practical use cases and boundaries.