更新泛型使用相关的文档

Author: realybin

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

@@ -110,13 +110,16 @@ 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__T1`（import 时）或 `` List`1 ``（load_type 时） | `puerts.generic(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_1`、`List`（import 时）或 `` List`1 ``（load_type 时） | `List[System.Int32]` |
 
-> 三种语言中反引号 `` ` `` 的替代符不同：JS 用 `$`，Lua 用 `_`，Python import 时用 `__T`。
+> 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 时用 `_`。
 
 ---
 
@@ -126,7 +129,7 @@ print(outB[0], refC[0])  # 100, 20
 |------|------|
 | **JavaScript** | 直接调用，V8 自动推断类型参数 |
 | **Lua** | `puerts.genericMethod(类型, '方法名', 泛型参数...)` |
-| **Python** | `puerts.genericMethod(类型, '方法名', 泛型参数...)` |
+| **Python** | `puerts.generic_method(类型, '方法名', 泛型参数...)` |
 
 ```lua
 -- Lua 示例
@@ -204,7 +207,7 @@ fn("hello");
 
 | 功能 | JavaScript (`puer.xxx`) | Lua (`require('puerts').xxx`) | Python (`puerts.xxx`) |
 |------|------------------------|------------------------------|----------------------|
-| 泛型类型 | `puer.$generic()` | `puerts.generic()` | `puerts.generic()` |
+| 泛型类型 | `puer.$generic()` | `puerts.generic()` | 使用 import 导入泛型即可 (import List_1/List)，细节参考上文对泛型的解释 |
 | 泛型方法 | — (自动推断) | `puerts.genericMethod()` | `puerts.genericMethod()` |
 | typeof | `puer.$typeof()` | `puerts.typeof()` | `puerts.typeof()` |
 | ref/out 创建 | `puer.$ref()` | `{}` (table) | `[]` (list) |

doc/unity/zhcn/tutorial/python2cs.md

@@ -173,33 +173,7 @@ print('ret=' + str(ret) + ', out=' + str(outRef[0]) + ', ref=' + str(refRef[0]))
 ----------------------------
 ### 泛型
 
-Python 中使用 `puerts.generic()` 来创建泛型类型：
-
-```csharp
-void Start() {
-    var env = new Puerts.ScriptEnv(new Puerts.BackendPython());
-    env.Eval(@"
-exec('''
-import System
-import System.Collections.Generic.List_1 as List
-
-# create generic type: List<int>
-ListInt = puerts.generic(List, System.Int32)
-ls = ListInt()
-ls.Add(1)
-ls.Add(2)
-ls.Add(3)
-
-print(ls.Count)  # 3
-''')
-");
-    env.Dispose();
-}
-```
-
-**方式二：使用中括号语法（推荐）**
-
-PuerTS 还支持 Python 风格的中括号语法来实例化泛型类型，类似于 Python 标准库中 `list[int]` 的写法：
+PuerTS 支持 Python 风格的中括号语法来实例化泛型类型，类似于 Python 标准库中 `list[int]` 的写法：
 
 ```csharp
 void Start() {
@@ -223,16 +197,22 @@ print(ls.Count)  # 3
 }
 ```
 
-中括号语法 `List_1[Int32]` 等价于 `puerts.generic(List_1, Int32)`，对于多个类型参数，使用逗号分隔：`Dictionary_2[String, Int32]`。
+以下导入语法都是等价的
+
+```python
+import System.Collections.Generic.List_1
+import System.Collections.Generic.List as List
+from System.Collections.Generic import List
+List_1 = puerts.load_type('System.Collections.Generic.List`1')
+```
+
+同时也都可以直接使用 `List[System.String]` 语法来创建泛型类型
+
+对于多个类型参数，使用逗号分隔：`Dictionary_2[String, Int32]`。
 
 > ⚠️ **泛型类名的特殊表示**：C# 中泛型类名使用反引号表示类型参数个数（如 `` List`1 ``），而在 Python 的 `import` 语法中，反引号需要替换为 `_` 加参数个数：
 > - `` List`1 `` → `List_1`
 > - `` Dictionary`2 `` → `Dictionary_2`
->
-> 使用 `puerts.load_type()` 时，可以直接使用反引号原始格式：
-> ```python
-> List = puerts.load_type('System.Collections.Generic.List`1')
-> ```
 
 ----------------------------
 ### 嵌套类型
@@ -253,11 +233,11 @@ x = InnerClassA()
 print(x.Foo)  # Hello
 
 # access generic nested class
-InnerClassB_1 = puerts.generic(TestNestedTypes.InnerClassB_1, Int32)
+InnerClassB_1 = TestNestedTypes.InnerClassB_1[Int32]
 y = InnerClassB_1()
 print(y.Bar)  # Hello
 
-InnerClassB_2 = puerts.generic(TestNestedTypes.InnerClassB_2, Int32, String)
+InnerClassB_2 = TestNestedTypes.InnerClassB_2[Int32, String]
 z = InnerClassB_2()
 print(z.Bar)  # Hello
 ''')
@@ -296,14 +276,14 @@ val = arr.get_Item(0)          # 等价于 C# 的 val = arr[0]
 print(val)                     # 42
 
 # 同样适用于 List<T>
-ListInt = puerts.generic(List_1, System.Int32)
+ListInt = List_1[System.Int32]
 lst = ListInt()
 lst.Add(10)
 first = lst.get_Item(0)       # 等价于 C# 的 lst[0]
 lst.set_Item(0, 20)           # 等价于 C# 的 lst[0] = 20
 
 # 同样适用于 Dictionary<TKey, TValue>
-DictStrInt = puerts.generic(Dictionary_2, System.String, System.Int32)
+DictStrInt = Dictionary_2[System.String, System.Int32]
 d = DictStrInt()
 d.set_Item('key', 100)        # 等价于 C# 的 dict['key'] = 100
 v = d.get_Item('key')         # 等价于 C# 的 v = dict['key']