📚 第二章：语法基础与数据类型

2.1 基本语法规则

语法特点

AI Script采用类似Python的简洁语法，同时融入了现代编程语言的特性：

• 缩进敏感：使用缩进表示代码块
• 类型推断：支持自动类型推断
• 表达式优先：一切皆表达式
• 函数式特性：支持高阶函数和闭包

基本结构

#!/usr/bin/env aiscript

# 导入语句
import ai
import std
import "custom-package" as custom

# 全局变量
GLOBAL_CONFIG = {
    "model": "gpt-4",
    "temperature": 0.7
}

# 函数定义
func greet(name: str) -> str {
    return f"Hello, {name}!"
}

# 类定义
class AIAssistant {
    private model: str
    private config: dict
    
    func __init__(model: str, config: dict = {}) {
        self.model = model
        self.config = config
    }
    
    func process(text: str) -> str {
        return ai.generate(text, model=self.model)
    }
}

# 主函数
func main() {
    assistant = AIAssistant("gpt-4")
    result = assistant.process("Hello, AI!")
    print(result)
}

# 程序入口
if __name__ == "__main__" {
    main()
}

注释规范

# 单行注释

"""
多行注释
用于详细说明
"""

# TODO: 待实现功能
# FIXME: 需要修复的问题
# NOTE: 重要说明

# 文档注释
func calculate_similarity(text1: str, text2: str) -> float {
    """
    计算两个文本的相似度
    
    Args:
        text1: 第一个文本
        text2: 第二个文本
    
    Returns:
        相似度分数 (0.0 - 1.0)
    
    Example:
        >>> calculate_similarity("hello", "hi")
        0.75
    """
    return ai.similarity(text1, text2)
}

2.2 数据类型系统

基本数据类型

数值类型

# 整数
age = 25
big_number = 1_000_000  # 支持下划线分隔
hex_value = 0xFF        # 十六进制
bin_value = 0b1010      # 二进制
oct_value = 0o755       # 八进制

# 浮点数
pi = 3.14159
scientific = 1.23e-4
infinity = float("inf")
nan_value = float("nan")

# 复数
complex_num = 3 + 4j

# 类型检查
print(type(age))        # <class 'int'>
print(isinstance(pi, float))  # True

字符串类型

# 字符串定义
single_quote = 'Hello'
double_quote = "World"
triple_quote = """
多行字符串
支持换行
"""

# 原始字符串
raw_string = r"C:\Users\path\file.txt"

# 格式化字符串
name = "Alice"
age = 30
formatted = f"My name is {name} and I'm {age} years old"

# 字符串方法
text = "  Hello, World!  "
print(text.strip())           # "Hello, World!"
print(text.upper())           # "  HELLO, WORLD!  "
print(text.replace("World", "AI"))  # "  Hello, AI!  "
print(text.split(","))        # ["  Hello", " World!  "]

# 字符串切片
text = "Hello, World!"
print(text[0:5])     # "Hello"
print(text[7:])      # "World!"
print(text[::-1])    # "!dlroW ,olleH"

布尔类型

# 布尔值
is_active = true
is_disabled = false

# 布尔运算
result1 = true and false   # false
result2 = true or false    # true
result3 = not true         # false

# 真值测试
print(bool(0))        # false
print(bool(1))        # true
print(bool(""))       # false
print(bool("hello"))  # true
print(bool([]))       # false
print(bool([1, 2]))   # true

集合数据类型

列表 (List)

# 列表创建
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, true]
empty_list = []

# 列表推导式
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 列表操作
numbers.append(6)           # 添加元素
numbers.insert(0, 0)        # 插入元素
numbers.remove(3)           # 删除元素
popped = numbers.pop()      # 弹出最后一个元素

# 列表切片
sublist = numbers[1:4]      # 获取子列表
numbers[1:3] = [10, 20]     # 切片赋值

# 列表方法
print(len(numbers))         # 长度
print(max(numbers))         # 最大值
print(min(numbers))         # 最小值
print(sum(numbers))         # 求和
numbers.sort()              # 排序
numbers.reverse()           # 反转

元组 (Tuple)

# 元组创建
point = (3, 4)
colors = ("red", "green", "blue")
single_tuple = (42,)        # 单元素元组
empty_tuple = ()

# 元组解包
x, y = point
first, *rest, last = colors

# 命名元组
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y)             # 3 4

字典 (Dictionary)

# 字典创建
person = {
    "name": "Alice",
    "age": 30,
    "city": "Beijing"
}

# 字典推导式
squares_dict = {x: x**2 for x in range(5)}

# 字典操作
print(person["name"])       # 访问值
person["email"] = "alice@example.com"  # 添加键值对
del person["age"]           # 删除键值对

# 字典方法
print(person.keys())        # 获取所有键
print(person.values())      # 获取所有值
print(person.items())       # 获取键值对
print(person.get("phone", "N/A"))  # 安全获取值

# 字典合并
defaults = {"theme": "dark", "language": "en"}
config = {"language": "zh", "debug": true}
merged = {**defaults, **config}  # {'theme': 'dark', 'language': 'zh', 'debug': true}

集合 (Set)

# 集合创建
fruits = {"apple", "banana", "orange"}
numbers = set([1, 2, 3, 3, 4])  # {1, 2, 3, 4}
empty_set = set()

# 集合操作
fruits.add("grape")         # 添加元素
fruits.remove("banana")     # 删除元素
fruits.discard("kiwi")      # 安全删除

# 集合运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

union = set1 | set2         # 并集: {1, 2, 3, 4, 5, 6}
intersection = set1 & set2  # 交集: {3, 4}
difference = set1 - set2    # 差集: {1, 2}
sym_diff = set1 ^ set2      # 对称差集: {1, 2, 5, 6}

AI特定数据类型

Tensor类型

import ai.tensor as tensor

# 创建张量
scalar = tensor.scalar(3.14)
vector = tensor.vector([1, 2, 3, 4])
matrix = tensor.matrix([
    [1, 2, 3],
    [4, 5, 6]
])

# 张量操作
result = matrix @ vector.reshape(3, 1)  # 矩阵乘法
sum_tensor = tensor.sum(matrix, axis=1)  # 按轴求和

# 张量属性
print(matrix.shape)         # (2, 3)
print(matrix.dtype)         # float32
print(matrix.device)        # cpu

Model类型

import ai.models as models

# 加载预训练模型
bert_model = models.load("bert-base-chinese")
gpt_model = models.load("gpt-3.5-turbo")

# 模型信息
print(bert_model.name)      # "bert-base-chinese"
print(bert_model.params)    # 110M
print(bert_model.device)    # "cuda:0"

# 模型推理
input_text = "今天天气很好"
embedding = bert_model.encode(input_text)
response = gpt_model.generate(input_text)

Dataset类型

import ai.data as data

# 创建数据集
train_data = data.Dataset([
    {"text": "正面评价", "label": 1},
    {"text": "负面评价", "label": 0}
])

# 数据集操作
train_data = train_data.shuffle()
train_data = train_data.batch(32)
train_data = train_data.map(lambda x: preprocess(x))

# 数据集属性
print(len(train_data))      # 数据集大小
print(train_data.columns)   # 列名

2.3 变量与常量

变量声明

# 动态类型
name = "Alice"              # 自动推断为str
age = 25                    # 自动推断为int
height = 1.75               # 自动推断为float

# 显式类型声明
name: str = "Alice"
age: int = 25
height: float = 1.75
scores: list[int] = [85, 90, 78]

# 可选类型
optional_value: int? = null
optional_value = 42

# 联合类型
value: int | str = "hello"
value = 123

常量定义

# 常量命名约定（全大写）
MAX_RETRIES = 3
API_BASE_URL = "https://api.example.com"
DEFAULT_CONFIG = {
    "timeout": 30,
    "retries": 3
}

# 枚举常量
enum Status {
    PENDING = "pending",
    RUNNING = "running",
    COMPLETED = "completed",
    FAILED = "failed"
}

# 使用枚举
current_status = Status.PENDING
if current_status == Status.RUNNING {
    print("任务正在运行")
}

作用域规则

# 全局作用域
global_var = "I'm global"

func outer_function() {
    # 函数作用域
    outer_var = "I'm in outer function"
    
    func inner_function() {
        # 嵌套作用域
        inner_var = "I'm in inner function"
        
        # 访问外层变量
        print(outer_var)    # 可以访问
        print(global_var)   # 可以访问
        
        # 修改外层变量
        nonlocal outer_var
        outer_var = "Modified from inner"
        
        # 修改全局变量
        global global_var
        global_var = "Modified globally"
    }
    
    inner_function()
    print(outer_var)        # "Modified from inner"
}

outer_function()
print(global_var)           # "Modified globally"

2.4 运算符与表达式

算术运算符

# 基本算术
a = 10
b = 3

print(a + b)    # 13 (加法)
print(a - b)    # 7  (减法)
print(a * b)    # 30 (乘法)
print(a / b)    # 3.333... (除法)
print(a // b)   # 3  (整除)
print(a % b)    # 1  (取模)
print(a ** b)   # 1000 (幂运算)

# 复合赋值
a += 5          # a = a + 5
a -= 2          # a = a - 2
a *= 3          # a = a * 3
a /= 2          # a = a / 2
a //= 2         # a = a // 2
a %= 3          # a = a % 3
a **= 2         # a = a ** 2

比较运算符

a = 10
b = 20

print(a == b)   # false (等于)
print(a != b)   # true  (不等于)
print(a < b)    # true  (小于)
print(a <= b)   # true  (小于等于)
print(a > b)    # false (大于)
print(a >= b)   # false (大于等于)

# 链式比较
print(1 < a < 15)  # true
print(5 <= a <= 15)  # true

逻辑运算符

a = true
b = false

print(a and b)  # false (逻辑与)
print(a or b)   # true  (逻辑或)
print(not a)    # false (逻辑非)

# 短路求值
result = a and expensive_function()  # 如果a为false，不会调用expensive_function
result = a or default_value()        # 如果a为true，不会调用default_value

位运算符

a = 0b1010  # 10
b = 0b1100  # 12

print(a & b)    # 0b1000 = 8  (按位与)
print(a | b)    # 0b1110 = 14 (按位或)
print(a ^ b)    # 0b0110 = 6  (按位异或)
print(~a)       # 按位取反
print(a << 2)   # 0b101000 = 40 (左移)
print(a >> 1)   # 0b101 = 5     (右移)

成员运算符

fruits = ["apple", "banana", "orange"]
text = "hello world"

print("apple" in fruits)        # true
print("grape" not in fruits)    # true
print("hello" in text)          # true
print("world" in text)          # true

身份运算符

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a is b)       # false (不是同一个对象)
print(a is c)       # true  (是同一个对象)
print(a == b)       # true  (值相等)
print(a is not b)   # true

三元运算符

# 条件表达式
age = 18
status = "adult" if age >= 18 else "minor"

# 空值合并
name = user_input or "Anonymous"
config = user_config ?? default_config

2.5 类型转换

隐式类型转换

# 数值类型自动提升
result = 10 + 3.14      # int + float -> float
result = 5 / 2          # int / int -> float

# 字符串连接
text = "Count: " + str(42)  # 需要显式转换

显式类型转换

# 基本类型转换
num_str = "123"
num = int(num_str)          # 字符串转整数
float_num = float(num_str)  # 字符串转浮点数
bool_val = bool(num)        # 数字转布尔值
str_val = str(num)          # 数字转字符串

# 集合类型转换
num_list = [1, 2, 3, 4, 5]
num_tuple = tuple(num_list)     # 列表转元组
num_set = set(num_list)         # 列表转集合
char_list = list("hello")       # 字符串转列表

# 错误处理
try {
    num = int("not_a_number")
} catch ValueError as e {
    print(f"转换错误: {e}")
}

AI类型转换

import ai.convert as convert

# 文本到向量
text = "Hello, world!"
vector = convert.text_to_vector(text)

# 图像到张量
image = load_image("photo.jpg")
tensor = convert.image_to_tensor(image)

# 数据格式转换
csv_data = load_csv("data.csv")
json_data = convert.csv_to_json(csv_data)
parquet_data = convert.json_to_parquet(json_data)

2.6 类型检查与注解

类型注解

# 函数类型注解
func add_numbers(a: int, b: int) -> int {
    return a + b
}

# 复杂类型注解
func process_data(
    data: list[dict[str, any]], 
    config: dict[str, str | int] = {}
) -> tuple[list[str], int] {
    # 处理逻辑
    return processed_items, count
}

# 泛型类型
func identity<T>(value: T) -> T {
    return value
}

# 回调函数类型
func apply_operation(
    numbers: list[int], 
    operation: func(int) -> int
) -> list[int] {
    return [operation(n) for n in numbers]
}

运行时类型检查

import typing

func validate_input(data: any) -> bool {
    # 检查是否为字符串
    if isinstance(data, str) {
        return len(data) > 0
    }
    
    # 检查是否为数字
    if isinstance(data, (int, float)) {
        return data > 0
    }
    
    # 检查是否为列表
    if isinstance(data, list) {
        return all(isinstance(item, str) for item in data)
    }
    
    return false
}

# 类型守卫
func is_string_list(value: any) -> bool {
    return (
        isinstance(value, list) and 
        all(isinstance(item, str) for item in value)
    )
}

if is_string_list(user_input) {
    # 在这个分支中，user_input被推断为list[str]
    for item in user_input {
        print(item.upper())  # 可以安全调用字符串方法
    }
}

自定义类型

# 类型别名
type UserId = int
type UserName = str
type UserData = dict[str, str | int]

# 使用类型别名
func get_user(user_id: UserId) -> UserData {
    return {
        "id": user_id,
        "name": "Alice",
        "age": 30
    }
}

# 数据类
@dataclass
class Point {
    x: float
    y: float
    
    func distance_to(other: Point) -> float {
        return ((self.x - other.x)**2 + (self.y - other.y)**2)**0.5
    }
}

# 枚举类型
enum Color {
    RED = "red",
    GREEN = "green",
    BLUE = "blue"
}

# 联合类型
type StringOrNumber = str | int
type OptionalString = str | null

2.7 内存管理

垃圾回收

import gc

# 手动触发垃圾回收
gc.collect()

# 查看内存使用情况
print(gc.get_stats())

# 设置垃圾回收阈值
gc.set_threshold(700, 10, 10)

弱引用

import weakref

class Node {
    func __init__(value: any) {
        self.value = value
        self.children = []
        self.parent = null
    }
    
    func add_child(child: Node) {
        child.parent = weakref.ref(self)  # 使用弱引用避免循环引用
        self.children.append(child)
    }
}

上下文管理

# 资源管理
with open("file.txt", "r") as file {
    content = file.read()
}  # 文件自动关闭

# 自定义上下文管理器
class DatabaseConnection {
    func __enter__() {
        self.connect()
        return self
    }
    
    func __exit__(exc_type, exc_val, exc_tb) {
        self.disconnect()
    }
    
    func connect() {
        print("连接数据库")
    }
    
    func disconnect() {
        print("断开数据库连接")
    }
}

with DatabaseConnection() as db {
    # 使用数据库连接
    result = db.query("SELECT * FROM users")
}  # 自动断开连接

本章小结

本章详细介绍了AI Script的语法基础和数据类型系统。通过学习本章，你应该：

• 掌握AI Script的基本语法规则和代码结构
• 了解各种数据类型及其使用方法
• 熟悉变量声明、常量定义和作用域规则
• 掌握各种运算符的使用
• 理解类型转换和类型检查机制
• 了解内存管理的基本概念

这些基础知识为后续学习控制结构、函数和AI集成奠定了坚实的基础。

---

练习题

1. 创建一个包含不同数据类型的复杂数据结构
2. 实现一个类型检查函数，验证输入数据的格式
3. 编写一个使用各种运算符的计算器程序
4. 设计一个自定义数据类型来表示AI模型的配置信息

下一章：第三章：控制结构与函数