更新文档 Python中泛型类型的创建和使用方式，简化泛型类名表示法

Author: realybin

doc/unity/en/tutorial/lang-comparison.md

@@ -114,9 +114,9 @@ print(outB[0], refC[0])  # 100, 20
 |----------|--------------------|---------------------|
 | **JavaScript** | `List$1` | `puer.$generic(CS.System.Collections.Generic.List$1, CS.System.Int32)` |
 | **Lua** | `List_1` | `puerts.generic(CS.System.Collections.Generic.List_1, CS.System.Int32)` |
-| **Python** | `List__T1` (import) or `` List`1 `` (load_type) | `puerts.generic(List, System.Int32)` |
+| **Python** | `List` | `List[System.Int32]` |
 
-> The backtick `` ` `` substitute differs across languages: JS uses `$`, Lua uses `_`, Python import uses `__T`.
+> In Python, using `import XXX` imports a special generic factory type. When called with type arguments, it creates an instance of a generic type based on the number of mixed-in type arguments.
 
 ---
 
@@ -126,7 +126,7 @@ print(outB[0], refC[0])  # 100, 20
 |----------|--------|
 | **JavaScript** | Call directly, V8 auto-infers type parameters |
 | **Lua** | `puerts.genericMethod(Type, 'MethodName', GenericArgs...)` |
-| **Python** | `puerts.genericMethod(Type, 'MethodName', GenericArgs...)` |
+| **Python** | `puerts.generic_method(Type, 'MethodName', GenericArgs...)` |
 
 ```lua
 -- Lua example
@@ -136,7 +136,21 @@ func(obj)
 
 ---
 
-## 10. typeof
+## 10. Array and Indexer Access (`[]` Operator)
+
+C# `[]` operators (arrays, `List`, `Dictionary`, custom indexers) **cannot** be accessed directly with `[]` in these three languages. You must use `get_Item()` / `set_Item()`.
+
+| Language | Read (C# `arr[0]`) | Write (C# `arr[0] = val`) |
+|----------|---------------------|---------------------------|
+| **JavaScript** | `arr.get_Item(0)` | `arr.set_Item(0, val)` |
+| **Lua** | `arr:get_Item(0)` | `arr:set_Item(0, val)` |
+| **Python** | `arr.get_Item(0)` | `arr.set_Item(0, val)` |
+
+> ⚠️ Lua uses colon `:` syntax for instance methods, while JS and Python use dot `.` syntax. This rule applies to all C# types with indexers (arrays, `List`, `Dictionary`, etc.).
+
+---
+
+## 11. typeof
 
 | Language | Syntax |
 |----------|--------|
@@ -146,7 +160,7 @@ func(obj)
 
 ---
 
-## 11. null Representation
+## 12. null Representation
 
 | Language | Script-side null | Notes |
 |----------|-----------------|-------|
@@ -156,7 +170,7 @@ func(obj)
 
 ---
 
-## 12. Callbacks / Lambda
+## 13. Callbacks / Lambda
 
 | Language | Example |
 |----------|---------|
@@ -174,7 +188,7 @@ fn("hello");
 
 ---
 
-## 13. Throwing Exceptions
+## 14. Throwing Exceptions
 
 | Language | Syntax |
 |----------|--------|
@@ -190,8 +204,8 @@ fn("hello");
 
 | Feature | JavaScript (`puer.xxx`) | Lua (`require('puerts').xxx`) | Python (`puerts.xxx`) |
 |---------|------------------------|------------------------------|----------------------|
-| Generic type | `puer.$generic()` | `puerts.generic()` | `puerts.generic()` |
-| Generic method | — (auto-inferred) | `puerts.genericMethod()` | `puerts.genericMethod()` |
+| Generic type | `puer.$generic()` | `puerts.generic()` | You can import the generic directly using `import` (e.g., `import List`). For details, refer to the explanation of generics above. |
+| Generic method | — (auto-inferred) | `puerts.genericMethod()` | `puerts.generic_method()` |
 | typeof | `puer.$typeof()` | `puerts.typeof()` | `puerts.typeof()` |
 | ref/out create | `puer.$ref()` | `{}` (table) | `[]` (list) |
 | ref/out retrieve | `puer.$unref()` | `[1]` | `[0]` |

doc/unity/en/tutorial/python2cs.md

@@ -50,24 +50,6 @@ Diagnostics.Debug.WriteLine('Test')
 
 PuerTS extends Python's `import` mechanism to directly import C# namespaces and types. You can use standard Python `import` / `from ... import` / `import ... as` syntax.
 
-**Method 2: Using `puerts.load_type()` for dynamic loading**
-
-```csharp
-void Start() {
-    var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
-    env.Eval(@"
-exec('''
-# load a type by full name string
-TestHelper = puerts.load_type('Puerts.UnitTest.TestHelper')
-Vector3 = puerts.load_type('UnityEngine.Vector3')
-''')
-");
-    env.Dispose();
-}
-```
-
-`puerts.load_type()` accepts a full type name string, which is useful when dynamically loading types or when the name contains special characters (such as the `+` sign for nested types).
-
 > ⚠️ **Note**: Accessing a non-existent namespace or type will throw a `ModuleNotFoundError` exception.
 
 ------------------
@@ -173,19 +155,19 @@ Unlike JS's `puer.$ref()` / `puer.$unref()` and Lua's table `{}` / `[1]`, Python
 ----------------------------
 ### Generics
 
-Use `puerts.generic()` to create generic types in Python:
+PuerTS supports Python-style square-bracket syntax for instantiating generic types, similar to the `list[int]` syntax in the Python standard library:
 
 ```csharp
 void Start() {
     var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
     env.Eval(@"
 exec('''
-import System
-import System.Collections.Generic.List_1 as List
+from System.Collections.Generic import List
+from System import Int32
 
-# create generic type: List<int>
-ListInt = puerts.generic(List, System.Int32)
-ls = ListInt()
+# use square bracket syntax to create generic type: List<int>
+List_Int32 = List[Int32]
+ls = List_Int32()
 ls.Add(1)
 ls.Add(2)
 ls.Add(3)
@@ -197,20 +179,20 @@ print(ls.Count)  # 3
 }
 ```
 
-> ⚠️ **Special naming for generic types**: In C#, generic type names use backticks to indicate the number of type parameters (e.g. `` List`1 ``). In Python's `import` syntax, backticks must be replaced with `_` followed by the count:
-> - `` List`1 `` → `List_1`
-> - `` Dictionary`2 `` → `Dictionary_2`
->
-> When using `puerts.load_type()`, you can use the original backtick format directly:
-> ```python
-> List = puerts.load_type('System.Collections.Generic.List`1')
-> ```
+The following import syntaxes are equivalent:
+
+```python
+import System.Collections.Generic.List as List
+from System.Collections.Generic import List
+```
+
+You can also directly use syntax like `List[System.String]` to create a generic type.
+
+For multiple type arguments, separate them with commas: `Dictionary[String, Int32]`.
 
 ----------------------------
 ### Nested Types
 
-C# nested types can be accessed in two ways:
-
 ```csharp
 void Start() {
     var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
@@ -219,34 +201,63 @@ exec('''
 from Puerts.UnitTest import TestNestedTypes
 from System import Int32, String
 
-# access nested class as attribute of outer class
+# access nested class as an attribute of the outer class
 InnerClassA = TestNestedTypes.InnerClassA
 x = InnerClassA()
 print(x.Foo)  # Hello
 
 # access generic nested class
-InnerClassB_1 = puerts.generic(TestNestedTypes.InnerClassB_1, Int32)
-y = InnerClassB_1()
+InnerClassB = TestNestedTypes.InnerClassB[Int32]
+y = InnerClassB()
 print(y.Bar)  # Hello
 
-InnerClassB_2 = puerts.generic(TestNestedTypes.InnerClassB_2, Int32, String)
-z = InnerClassB_1()
+InnerClassB = TestNestedTypes.InnerClassB[Int32, String]
+z = InnerClassB()
 print(z.Bar)  # Hello
 ''')
 ");
     env.Dispose();
 }
+```
+
+----------------------------
+### Array and Indexer Access
+
+C# `[]` operators (including array indexing, `List` indexing, `Dictionary` indexing, and any custom indexer) **cannot** be accessed directly with Python `[]` syntax for C# objects. You must use `get_Item()` / `set_Item()`:
 
-// use load_type for nested types (with '+' separator)
-env.Eval(@"
+```csharp
+void Start() {
+    var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
+    env.Eval(@"
 exec('''
-Inner = puerts.load_type('Puerts.UnitTest.CSharpModuleTestPython+Inner')
-print(Inner.i)  # 3
+import System
+from System.Collections.Generic import List, Dictionary
+
+# create C# array
+arr = System.Array.CreateInstance(puerts.typeof(System.Int32), 3)
+arr.set_Item(0, 42)            # equivalent to C#: arr[0] = 42
+val = arr.get_Item(0)          # equivalent to C#: val = arr[0]
+print(val)                     # 42
+
+# also applies to List<T>
+ListInt = List[System.Int32]
+lst = ListInt()
+lst.Add(10)
+first = lst.get_Item(0)       # equivalent to C#: lst[0]
+lst.set_Item(0, 20)           # equivalent to C#: lst[0] = 20
+
+# also applies to Dictionary<TKey, TValue>
+DictStrInt = Dictionary[System.String, System.Int32]
+d = DictStrInt()
+d.set_Item('key', 100)        # equivalent to C#: dict['key'] = 100
+v = d.get_Item('key')         # equivalent to C#: v = dict['key']
 ''')
 ");
+    env.Dispose();
+}
 ```
 
-> 💡 When using `puerts.load_type()` to access nested types, use the C# reflection `+` separator format (e.g. `OuterClass+InnerClass`).
+> ⚠️ **Important**: Although Python native `[]` is used for Python lists/dicts, index access on C# objects must use `get_Item()` / `set_Item()`. This is consistent with JS and Lua rules.
 
 ----------------------------
 ### typeof
@@ -400,6 +411,40 @@ void Start() {
 }
 ```
 
+----------------------------
+### Iterators
+
+Use `puerts.gen_iterator()` to convert C# iterable objects (objects implementing `IEnumerable`) into Python iterators, so you can use Python `for ... in` loops:
+
+```csharp
+void Start() {
+    var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
+    env.Eval(@"
+exec('''
+from System.Collections.Generic import List
+from System import Int32
+
+List_Int32 = List[Int32]
+myList = List_Int32()
+myList.Add(1)
+myList.Add(2)
+myList.Add(3)
+
+# convert C# IEnumerable to Python iterator
+iter = puerts.gen_iterator(myList)
+result = []
+for i in iter:
+    result.append(i)
+
+print(result)  # [1, 2, 3]
+''')
+");
+    env.Dispose();
+}
+```
+
+`puerts.gen_iterator()` internally calls the object's `GetEnumerator()` method and wraps it as an iterator object that supports Python iteration protocol (`__iter__` / `__next__`).
+
 -------------
 This section covers calling C# from Python. In the next section, we'll go the other direction: [Invoking Python from C#](./cs2python.md).
 

doc/unity/zhcn/tutorial/lang-comparison.md

@@ -110,16 +110,13 @@ print(outB[0], refC[0])  # 100, 20
 
 ## 8. 泛型类型创建
 
-| 语言 | 泛型类名写法                                         | 创建 `List<int>` |
-|------|------------------------------------------------|-----------------|
-| **JavaScript** | `List$1`                                       | `puer.$generic(CS.System.Collections.Generic.List$1, CS.System.Int32)` |
-| **Lua** | `List_1`                                       | `puerts.generic(CS.System.Collections.Generic.List_1, CS.System.Int32)` |
-| **Python** | `List_1`、`List`（import 时）或 `` List`1 ``（load_type 时） | `List[System.Int32]` |
+| 语言 | 泛型类名写法  | 创建 `List<int>` |
+|------|--------------------------------------|-----------------|
+| **JavaScript** | `List$1`  | `puer.$generic(CS.System.Collections.Generic.List$1, CS.System.Int32)` |
+| **Lua** | `List_1`  | `puerts.generic(CS.System.Collections.Generic.List_1, CS.System.Int32)` |
+| **Python** | `List` | `List[System.Int32]` |
 
-> Python 使用 `import XXX_1` 或 ``load_type['XXX`1']`` 来获取泛型类型时，会导入类型 ``XXX`1``，而使用 `import XXX` 则会导入一个特殊的泛型工厂类型，调用时传入类型参数即可根据掺入的类型参数数量创建泛型类型实例。
-> 两者都可以使用 `List[System.Int32]` 来创建 `List<int>`，但前者需要（也可以用as来调整为`List`）写成 `List_1[System.Int32]`，后者则更简洁。
-
-> 三种语言中反引号 `` ` `` 的替代符不同：JS 用 `$`，Lua 用 `_`，Python import 时用 `_`。
+> Python 使用 `import XXX` 会导入一个特殊的泛型工厂类型，调用时传入类型参数即可根据掺入的类型参数数量创建泛型类型实例。
 
 ---
 
@@ -207,7 +204,7 @@ fn("hello");
 
 | 功能 | JavaScript (`puer.xxx`) | Lua (`require('puerts').xxx`) | Python (`puerts.xxx`) |
 |------|------------------------|------------------------------|----------------------|
-| 泛型类型 | `puer.$generic()` | `puerts.generic()` | 使用 import 导入泛型即可 (import List_1/List)，细节参考上文对泛型的解释 |
+| 泛型类型 | `puer.$generic()` | `puerts.generic()` | 使用 import 导入泛型即可 (import List)，细节参考上文对泛型的解释 |
 | 泛型方法 | — (自动推断) | `puerts.genericMethod()` | `puerts.genericMethod()` |
 | typeof | `puer.$typeof()` | `puerts.typeof()` | `puerts.typeof()` |
 | ref/out 创建 | `puer.$ref()` | `{}` (table) | `[]` (list) |