扣子（Coze）工作流实战：惊呆了！这个“四格转动”特效书单视频直接爆了！

## 技能
### 技能 1: 生成插图画面描述prompt
1.当用户给出书籍名称《{{input}}》时，深入理解书籍的内容风格、主题、情节等关键信息。
2.基于对书籍的理解，生成一幅符合书籍内容风格且具有艺术风格的插图画面描述。
3.在画面描述中，严格避免出现亮色和红色。

## 角色概述：
你的核心职责是根据用户提供的书籍名称和相关主题关键词，创作出具有强烈的感情共鸣、能迅速抓住读者注意力、并引发读者思考和行动的高质量书单短文案。

## 目标：
1.创作引人入胜的书单文案： 针对用户提供的书籍名称和主题，生成能够立即吸引用户的短文案。
2.实现高情感共鸣和用户互动： 文案需触及用户内心深处的情感需求，激发共鸣，并引导用户对书籍产生兴趣，最终实现“始于好奇，忠于内容”的转化。

## 技能：
1.情感挖掘与连接： 能够深入理解书籍的核心情感、主题思想，并将其转化为能够触动人心的语言，与读者普遍的情感体验产生共鸣。
2.结构化文案创作： 掌握“黄金三秒法则”（吸引眼球的开头）、“痛点共鸣”、“核心洞察与情感连接”、“价值启发”以及“震撼心灵的金句结尾”等关键文案结构，并能灵活运用。
3.语言炼金术： 精准运用词汇，创造具有画面感、力量感和哲思性的短语，使文案简洁而富有深度。

## 工作流：
1.接收并解析用户输入： 接收用户提供的“书籍名称+主题关键词”格式的请求。
2.深度分析书籍与主题： 基于对书籍的理解，挖掘出其核心价值、最能引起共鸣的情感点以及与用户主题关键词的关联。
3.构建符合结构的文案： 按照预设的文案结构（开头、痛点、洞察、启发、金句结尾），填充具体内容，确保每个环节都紧密衔接，层层递进，最终形成一个完整的、有冲击力的短文案。

## 限制：
1.开始第一句必须包含书籍的名字。
2.结尾最后一句话只输出金句，不要有过多的解释。
3.整体文案字数在500~600字之间。
4.输出格式必须是JSON数组格式。
5.数组至少包含10个句子，每一个句子长度不超过18个字。
6.每句话中可以包含逗号或顿号，但句末不能带任何标点符号。

# 定义输入参数的类型。
# 这里的 Args 是一个字典，它里面有一个键是 "params"。
# "params" 的值也是一个字典，里面包含我们需要处理的时间线数据。
classArgs(TypedDict):
params:Dict[str,Any]

# 定义输出结果的类型。
# 我们的输出是一个字典，里面包含四条时间线：timeline1, timeline2, timeline3, timeline4。
# 每条时间线都是一个列表，列表里的每个元素又是一个字典，包含 "start" 和 "end" 两个时间点。
classOutput(TypedDict):
timeline1:List[Dict[str,int]] # 原始时间线中的第一个元素的 start 和 end 时间
timeline2:List[Dict[str,int]] # 从第二个元素的 start 到倒数第二个元素的 end
timeline3:List[Dict[str,int]] # 原始时间线中，从第二个元素开始到倒数第二个元素结束的所有元素的 start 和 end 时间
timeline4:List[Dict[str,int]] # 原始时间线中的最后一个元素的 start 和 end 时间

# 这是一个异步函数，名字叫 main，它接收一个 Args 类型的参数，并返回一个 Output 类型的结果。
# 异步函数意味着它可以等待其他操作完成，而不会阻塞整个程序的运行。
asyncdefmain(args: Args) -> Output:
try:
# 从输入参数 args 中取出 params 字典。
# params 字典里包含了我们需要处理的原始时间线数据。
params = args["params"]

# 从 params 字典中取出名为 "timelines" 的列表，这个列表就是我们要处理的原始时间线。
# 每一项都是一个字典，包含 "start" 和 "end" 两个时间点（这里假设是微秒）。
timelines = params["timelines"]

# 检查 timelines 是否为空。如果为空，就抛出一个错误，因为我们需要有数据才能处理。
ifnottimelines:
raiseValueError("输入的时间线 (timelines) 不能为空")

# --- 处理 timeline1 ---
# 目标：提取 timelines 中的第一个元素的 start 和 end 时间。
# 创建一个空的列表 timeline1，用来存放处理后的第一个时间线数据。
timeline1 = []
# 检查 timelines 是否有至少一个元素。
iftimelines:
# 获取 timelines 的第一个元素。Python 的列表索引是从 0 开始的。
first_item = timelines[0]
# 将第一个元素的 "start" 和 "end" 时间存入一个字典。
# 然后把这个字典添加到 timeline1 列表中。
timeline1.append({
"start": first_item["start"], # 获取第一个元素的 start 时间
"end": first_item["end"] # 获取第一个元素的 end 时间
})

# --- 处理 timeline2 ---
# 目标：提取原始时间线中，从第二个元素的 start 到倒数第二个元素的 end。
# 这个新的时间线只包含一个 start 和一个 end。
# 创建一个空的列表 timeline2，用来存放处理后的第二个时间线数据。
timeline2 = []
# 检查 timelines 的元素数量是否至少为 3。
# 为什么是至少 3 个？
# 因为我们需要：
# 1. 第二个元素 (索引 1)，所以至少要有索引 1，这意味着总数至少是 2 个。
# 2. 倒数第二个元素 (索引 -2)，所以至少要有索引 -2，这意味着总数至少是 3 个 (因为索引 -1 是最后一个)。
# 例如：
# - 如果 timelines 是 [A] (1个)，没有第二个元素，也没有倒数第二个元素。
# - 如果 timelines 是 [A, B] (2个)，有第二个元素 B (索引 1)，但没有倒数第二个元素（因为倒数第二个就是第一个 A）。
# - 如果 timelines 是 [A, B, C] (3个)，第二个元素是 B (start: B["start"])，倒数第二个元素是 B (end: B["end"])。
# - 如果 timelines 是 [A, B, C, D] (4个)，第二个元素是 B (start: B["start"])，倒数第二个元素是 C (end: C["end"])。
iflen(timelines) >=3:# 确保有足够的元素来获取第二个和倒数第二个
# 获取第二个元素的 start 时间。第二个元素的索引是 1。
start_time_for_timeline2 = timelines[1]["start"]
# 获取倒数第二个元素的 end 时间。倒数第二个元素的索引是 -2。
end_time_for_timeline2 = timelines[-2]["end"]

# 将这两个时间点组合成一个字典，并添加到 timeline2 列表中。
# 注意：即使 timelines 只有 3 个元素，比如 [A, B, C]，
# timelines[1] 是 B，timelines[-2] 也是 B。所以 B 的 start 和 B 的 end 会被提取出来。
timeline2.append({
"start": start_time_for_timeline2,
"end": end_time_for_timeline2
})
# 如果 timelines 的元素数量少于 3，则 timeline2 列表保持为空。

# --- 处理 timeline3 ---
# 目标：提取 timelines 从第二个元素开始，一直到倒数第二个元素的 start 和 end 时间。
# 创建一个空的列表 timeline3，用来存放处理后的第三个时间线数据。
timeline3 = []
# 检查 timelines 的元素数量是否大于等于 2。
# 因为我们要取第二个到倒数第二个，所以至少需要 2 个元素。
# 如果元素数量小于 2，意味着没有“中间”的元素，所以 timeline3 会是空列表。
iflen(timelines) >=2:
# 使用切片 `timelines[1:-1]` 来获取“中间”的元素。
# `[1]` 表示从索引为 1 的元素开始取（也就是第二个元素）。
# `[:-1]` 表示一直取到索引为 -1 的元素之前（也就是倒数第二个元素）。
# 这样就能包含从第二个元素到倒数第二个元素的所有元素。
foritemintimelines[1:-1]:
# 对于每一个从切片中取出来的元素（也就是符合条件的“中间”元素），
# 将它的 "start" 和 "end" 时间存入一个字典。
# 然后把这个字典添加到 timeline3 列表中。
timeline3.append({
"start": item["start"], # 获取当前中间元素的 start 时间
"end": item["end"] # 获取当前中间元素的 end 时间
})

# --- 处理 timeline4 ---
# 目标：提取 timelines 中的最后一个元素的 start 和 end 时间。
# 创建一个空的列表 timeline4，用来存放处理后的第四个时间线数据。
timeline4 = []
# 检查 timelines 是否有至少一个元素。
iftimelines:
# 获取 timelines 的最后一个元素。
# Python 的负索引 `-1` 表示最后一个元素。
last_item = timelines[-1]
# 将最后一个元素的 "start" 和 "end" 时间存入一个字典。
# 然后把这个字典添加到 timeline4 列表中。
timeline4.append({
"start": last_item["start"], # 获取最后一个元素的 start 时间
"end": last_item["end"] # 获取最后一个元素的 end 时间
})

# 将处理好的四条时间线组成一个字典，作为最终的输出结果。
ret: Output = {
"timeline1": timeline1, # 第一条时间线：原始的第一个元素的 start 和 end
"timeline2": timeline2, # 第二条时间线：从第二个元素的 start 到倒数第二个元素的 end
"timeline3": timeline3, # 第三条时间线：原始的第二个到倒数第二个元素（包含所有中间元素）的 start 和 end
"timeline4": timeline4 # 第四条时间线：原始的最后一个元素的 start 和 end
}
# 返回最终的结果。
returnret

# 定义输入参数的类型。
# 这里的 Args 是一个字典，它里面有一个键是 "params"。
# "params" 的值也是一个字典，里面包含我们需要处理的字符串数组 "input"。
classArgs(TypedDict):
params:Dict[str,Any]

# 定义输出结果的类型。
# 我们的输出是一个字典，里面包含三个部分：start_array, end_array, text_array。
# 每一部分都是一个列表（Python 中的数组类型），用来存放转换后的数据。
classOutput(TypedDict):
start_array:List[str] # 输入数组的第一个元素，转换为列表
end_array:List[str] # 输入数组的最后一个元素，转换为列表
text_array:List[str] # 输入数组除去第一个和最后一个元素后的所有剩余元素，转换为列表

# 这是一个异步函数，名字叫 main，它接收一个 Args 类型的参数，并返回一个 Output 类型的结果。
# 异步函数意味着它可以等待其他操作完成，而不会阻塞整个程序的运行。
asyncdefmain(args: Args) -> Output:
try:
# 从输入参数 args 中取出 params 字典。
# params 字典里包含了我们需要处理的原始数据。
params = args["params"]

# 从 params 字典中取出名为 "input" 的列表（字符串数组）。
# 这个列表就是我们要拆分和转换的原始数据。
input_list = params["input"]# 我们用 input_list 来避免和 Python 的内建函数 input() 冲突

# 检查 input_list 是否为空。如果为空，就抛出一个错误，因为我们需要有数据才能处理。
ifnotinput_list:
raiseValueError("输入的字符串数组 (input) 不能为空")

# --- 处理 start_array ---
# 目标：取出 input_list 的第一个元素，并将其转换为一个只包含这个元素的列表。
# 创建一个空的列表 start_array，用来存放处理后的第一个部分。
start_array:List[str] = []
# 检查 input_list 是否有至少一个元素。
ifinput_list:
# 获取 input_list 的第一个元素。Python 的列表索引是从 0 开始的。
first_element = input_list[0]
# 将这个第一个元素添加到 start_array 列表中。
# 因为我们要求是“转成数组类型”，这里是创建一个包含这个元素的列表。
start_array.append(first_element)

# --- 处理 end_array ---
# 目标：取出 input_list 的最后一个元素，并将其转换为一个只包含这个元素的列表。
# 创建一个空的列表 end_array，用来存放处理后的最后一个部分。
end_array:List[str] = []
# 检查 input_list 是否有至少一个元素。
ifinput_list:
# 获取 input_list 的最后一个元素。Python 的负索引 `-1` 表示最后一个元素。
last_element = input_list[-1]
# 将这个最后一个元素添加到 end_array 列表中。
# 同样，这里是创建一个包含这个元素的列表。
end_array.append(last_element)

# --- 处理 text_array ---
# 目标：取出 input_list 中除了第一个和最后一个元素之外的所有剩余数据，并将它们转换为一个列表。
# 创建一个空的列表 text_array，用来存放处理后的中间部分。
text_array:List[str] = []
# 检查 input_list 的元素数量是否大于等于 2。
# 因为我们需要去掉第一个和最后一个，所以至少需要两个元素。
# 如果元素数量小于 2，意味着没有“中间”的元素，所以 text_array 会是空列表。
iflen(input_list) >=2:
# 使用切片 `input_list[1:-1]` 来获取“中间”的元素。
# `[1]` 表示从索引为 1 的元素开始取（也就是第二个元素）。
# `[:-1]` 表示一直取到索引为 -1 的元素之前（也就是最后一个元素）。
# 这样就能包含从第二个元素到倒数第二个元素的所有元素。
# 如果 input_list 只有两个元素（比如 `[A, B]`），那么 `[1:-1]` 会得到一个空列表 `[]`。
# 这个切片操作会返回一个新的列表，其中包含了所有符合条件的“中间”元素。
# 我们直接将这个切片的结果赋值给 text_array。
text_array = input_list[1:-1]
# 注意：这里直接赋值 `text_array = input_list[1:-1]` 就可以了，
# 因为切片本身就返回一个列表（数组类型）。

# 将处理好的三部分数据组成一个字典，作为最终的输出结果。
ret: Output = {
"start_array": start_array, # 第一个元素组成的列表
"end_array": end_array, # 最后一个元素组成的列表
"text_array": text_array # 除首尾外的所有元素组成的列表
}
# 返回最终的结果。
returnret