如何使用 LangChain 进行记忆管理

最新推荐文章于 2024-11-02 16:28:26 发布
最新推荐文章于 2024-11-02 16:28:26 发布
阅读量645 收藏 13
点赞数 11
文章标签： langchain python 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48967543/article/details/142338781
版权

聊天机器人的一个主要特点是能使用以前的对话内容作为上下文。这种状态管理有多种形式，包括：

  • 简单地将以前的信息塞进聊天模型提示中。
  • 如上，但会修剪旧信息，以减少模型需要处理的干扰信息量。
  • 更复杂的修改，如为长对话合成摘要。

Setup

1

%pip install --upgrade --quiet langchain==0.1.20 langchain-google-genai

1
2
3

from langchain_google_genai import ChatGoogleGenerativeAI

chat = ChatGoogleGenerativeAI(model="gemini-1.5-pro-latest", google_api_key=API_KEY)

Message Passing

最简单的记忆形式就是将聊天记录信息传递到一个链中。下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from langchain_core.messages import AIMessage, HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful assistant. Answer all questions to the best of your ability.",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

chain = prompt | chat

response = chain.invoke(
    {
        "messages": [
            HumanMessage(
                content="Translate this sentence from English to French: I love programming."
            ),
            AIMessage(content="J'adore la programmation."),
            HumanMessage(content="What did you just say?"),
        ],
    }
)
response

1

AIMessage(content='I said "J\'adore la programmation" which is the French translation for "I love programming". \n', response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]}, id='run-88045024-xxx-xxx-xxx-35fe7f321bbe-0')

我们可以看到，通过将之前的对话传递到链中，聊天机器人可以将其作为回答问题的上下文。这就是聊天机器人记忆的基本概念。

Chat Message History

直接以数组形式存储和传递消息完全没问题，但我们也可以使用 LangChain 内置的消息历史记录类来存储和加载消息。

1
2
3
4
5
6
7
8
9

from langchain.memory import ChatMessageHistory

demo_ephemeral_chat_history = ChatMessageHistory()
demo_ephemeral_chat_history.add_user_message(
    "Translate this sentence from English to French: I love programming."
)
demo_ephemeral_chat_history.add_ai_message("J'adore la programmation.")

demo_ephemeral_chat_history

1

InMemoryChatMessageHistory(messages=[HumanMessage(content='Translate this sentence from English to French: I love programming.'), AIMessage(content="J'adore la programmation.")])

我们可以直接用它来为我们的链存储多轮对话：

1
2
3
4
5
6
7
8
9
10
11

demo_ephemeral_chat_history = ChatMessageHistory()

input1 = "Translate this sentence from English to French: I love programming."
demo_ephemeral_chat_history.add_user_message(input1)

response = chain.invoke(
    {
        "messages": demo_ephemeral_chat_history.messages,
    }
)
response

1

AIMessage(content="J'adore programmer. \n", response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]}, id='run-5b427786-xxx-xxx-xxx-c6e6137c4df5-0')

记忆类型

LangChain 包含了以下几种记忆类型，通常这些类型会与 LLMs 结合使用。

Conversation Buffer www.cqzlsb.com

ConversationBufferMemory 是一种极其简单的记忆形式，它所做的就是把聊天消息保存在内存中，并将这些消息输入到提示模板。

1
2
3
4
5
6
7

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

memory

1

ConversationBufferMemory(chat_memory=InMemoryChatMessageHistory(messages=[HumanMessage(content='hi!'), AIMessage(content="what's up?")]))

另一种使用方式：

1
2
3
4
5
6

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "hi"}, {"output": "whats up"})

memory.load_memory_variables({})

1

{'history': 'Human: hi\nAI: whats up'}

在这个示例中，你可以注意到 load_memory_variables 返回了一个名为 history 的键值。这意味着你的链（以及可能的输入提示词）可能会期望一个名为 history 的输入。一般而言，你可以通过在记忆类中设置参数来管理这个变量。例如，如果你希望记忆变量在 chat_history 关键字中返回，你可以这样做：

1
2
3
4
5

memory = ConversationBufferMemory(memory_key="chat_history")
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

memory.load_memory_variables({})

1

{'chat_history': "Human: hi!\nAI: what's up?"}

另外，最常见的一种使用记忆的方式是返回聊天信息的列表。这些信息可以整合成一个字符串返回（当要传入 LLMs 时 这种方式很有用）或者作为一个聊天消息的列表返回（在传入 ChatModels 时这种方式很有用）。

默认情况下，它们以一整串字符串的方式返回。为了以消息列表的形式返回，你可以设置 return_messages=True。

1
2
3
4
5
6

memory = ConversationBufferMemory(return_messages=True)

memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")

memory.load_memory_variables({})

1

{'history': [HumanMessage(content='hi!'), AIMessage(content="what's up?")]}

以下是与链结合使用的示例：

1
2
3
4
5
6
7
8
9
10
11

from langchain_google_genai import GoogleGenerativeAI
from langchain.chains import ConversationChain

llm = GoogleGenerativeAI(model="gemini-1.5-pro-latest", google_api_key=API_KEY)
conversation = ConversationChain(
    llm=llm,
    verbose=True,
    memory=ConversationBufferMemory()
)

conversation.predict(input="Hi there!")

输出


 

Conversation Buffer Window

ConversationBufferWindowMemory 跟踪并保存随时间发展的对话互动列表。它只保留最近的 K 次对话记录。这种做法有助于创建一个包含最新互动记录的滑动视窗，可以有效地避免缓存变得过大。

1
2
3
4
5
6
7

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=1)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})

memory.load_memory_variables({})

1

{'history': 'Human: not much you\nAI: not much'}

1
2
3
4
5

memory = ConversationBufferWindowMemory(k=1, return_messages=True)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})

memory.load_memory_variables({})

1

{'history': [HumanMessage(content='not much you'), AIMessage(content='not much')]}

Entity

实体记忆在对话中记住了关于特定实体的既定事实。它提取关于实体的信息（使用一个 LLM）并且随着时间的推移建立起关于该实体的知识（也使用一个 LLM）。

1
2
3
4
5
6

from langchain.memory import ConversationEntityMemory

memory = ConversationEntityMemory(llm=llm)
_input = {"input": "Deven & Sam are working on a hackathon project"}
memory.load_memory_variables(_input)
memory

1
2
3
4
5
6
7

ConversationEntityMemory(llm=GoogleGenerativeAI(model='gemini-1.5-pro-latest', google_api_key=SecretStr('**********'), client=genai.GenerativeModel(
    model_name='models/gemini-1.5-pro-latest',
    generation_config={},
    safety_settings={},
    tools=None,
    system_instruction=None,
)), entity_cache=['Deven', 'Sam'])

1
2
3
4
5

memory.save_context(
    _input,
    {"output": " That sounds like a great project! What kind of project are they working on?"}
)
memory

1
2
3
4
5
6
7

ConversationEntityMemory(chat_memory=InMemoryChatMessageHistory(messages=[HumanMessage(content='Deven & Sam are working on a hackathon project'), AIMessage(content=' That sounds like a great project! What kind of project are they working on?')]), llm=GoogleGenerativeAI(model='gemini-1.5-pro-latest', google_api_key=SecretStr('**********'), client=genai.GenerativeModel(
    model_name='models/gemini-1.5-pro-latest',
    generation_config={},
    safety_settings={},
    tools=None,
    system_instruction=None,
)), entity_cache=['Deven', 'Sam'], entity_store=InMemoryEntityStore(store={'Deven': 'Updated summary: Deven is working on a hackathon project with Sam.', 'Sam': 'Updated summary: Sam is working on a hackathon project with Deven.'}))

1

memory.load_memory_variables({"input": 'who is Sam'})

1
2

{'history': 'Human: Deven & Sam are working on a hackathon project\nAI:  That sounds like a great project! What kind of project are they working on?',
 'entities': {'Sam': 'Updated summary: Sam is working on a hackathon project with Deven.'}}

1
2
3
4
5
6
7
8
9

memory = ConversationEntityMemory(llm=llm, return_messages=True)

_input = {"input": "Deven & Sam are working on a hackathon project"}
memory.load_memory_variables(_input)
memory.save_context(
    _input,
    {"output": " That sounds like a great project! What kind of project are they working on?"}
)
memory.load_memory_variables({"input": 'who is Sam'})

1
2
3
4

WARNING:langchain_core.language_models.llms:Retrying langchain_google_genai.llms._completion_with_retry.<locals>._completion_with_retry in 10.0 seconds as it raised ResourceExhausted: 429 Resource has been exhausted (e.g. check quota)..
{'history': [HumanMessage(content='Deven & Sam are working on a hackathon project'),
  AIMessage(content=' That sounds like a great project! What kind of project are they working on?')],
 'entities': {'Sam': 'Updated summary:\nSam is working on a hackathon project with Deven.'}}

Conversation Knowledge Graph

这种类型的记忆使用知识图谱来重建记忆。

1
2
3
4
5
6
7

from langchain.memory import ConversationKGMemory

memory = ConversationKGMemory(llm=llm)
memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})
memory.save_context({"input": "sam is a friend"}, {"output": "okay"})

memory.load_memory_variables({"input": "who is sam"})

1

{'history': 'On Sam: Sam is a friend.'}

我们也可以更加模块化地从一条新消息中获取当前实体（将使用之前的消息作为上下文）。

1

memory.get_current_entities("what's Sams favorite color?")

['Sams']

我们也可以更加模块化地从一条新消息中获取知识三元组（将使用之前的消息作为上下文）。

1

memory.get_knowledge_triplets("her favorite color is red")

1

[KnowledgeTriple(subject='her', predicate='favorite color', object_='red')]

Conversation Summary

现在让我们来看一个略微复杂的记忆类型 ConversationSummaryMemory。这种记忆类型会随着时间的推移创建对话的总结。这对于压缩对话中随时间积累的信息是有用的。会话总结记忆在对话发生时总结内容，并将当前的总结存储在记忆中。这个记忆之后可以用来将到目前为止的对话总结注入到一个提示词/链中。这种记忆对长时间的对话最有用，因为如果直接在提示词中保持之前的消息历史会占用太多的 Token。

1
2
3
4
5
6

from langchain.memory import ConversationSummaryMemory, ChatMessageHistory

memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "hi"}, {"output": "whats up"})

memory.load_memory_variables({})

我们也可以直接利用 predict_new_summary 方法：

1
2

messages = memory.chat_memory.messages
messages

1

[HumanMessage(content='hi'), AIMessage(content='whats up')]

1
2

previous_summary = ""
memory.predict_new_summary(messages, previous_summary)

'Current summary:\nThe human greeted the AI. The AI responded by asking what was happening. \n'

你可以轻松地用 ChatMessageHistory 初始化 ConversationSummaryMemory。在加载时，会自动生成一个总结。

1
2
3
4
5
6
7
8
9
10

history = ChatMessageHistory()
history.add_user_message("hi")
history.add_ai_message("hi there!")

memory = ConversationSummaryMemory.from_messages(
    llm=llm,
    chat_memory=history,
    return_messages=True
)
memory

1
2
3
4
5
6
7

ConversationSummaryMemory(llm=GoogleGenerativeAI(model='gemini-1.5-pro-latest', google_api_key=SecretStr('**********'), client=genai.GenerativeModel(
    model_name='models/gemini-1.5-pro-latest',
    generation_config={},
    safety_settings={},
    tools=None,
    system_instruction=None,
)), chat_memory=InMemoryChatMessageHistory(messages=[HumanMessage(content='hi'), AIMessage(content='hi there!')]), return_messages=True, buffer='Current summary: \nThe human greeted the AI. The AI returned the greeting. \n')

1

memory.buffer

'Current summary: \nThe human greeted the AI. The AI returned the greeting. \n'

你可以使用之前生成的总结来加速初始化，并通过直接初始化来避免重新生成总结。

1
2
3
4
5
6
7

memory = ConversationSummaryMemory(
    llm=llm,
    buffer="The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.",
    chat_memory=history,
    return_messages=True
)
memory

1
2
3
4
5
6
7

ConversationSummaryMemory(llm=GoogleGenerativeAI(model='gemini-1.5-pro-latest', google_api_key=SecretStr('**********'), client=genai.GenerativeModel(
    model_name='models/gemini-1.5-pro-latest',
    generation_config={},
    safety_settings={},
    tools=None,
    system_instruction=None,
)), chat_memory=InMemoryChatMessageHistory(messages=[HumanMessage(content='hi'), AIMessage(content='hi there!')]), return_messages=True, buffer='The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.')

Conversation Token Buffer

ConversationTokenBufferMemory 在内存中保持了一段最近互动的缓存，并使用 Token 的长度而不是互动的数量来决定何时清除互动。

1
2
3
4
5
6
7

from langchain.memory import ConversationTokenBufferMemory

memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})

memory.load_memory_variables({})

1

{'history': 'Human: not much you\nAI: not much'}

Conversation Summary Buffer

ConversationSummaryBufferMemory 融合了两种方法。它会在内存中保留最近交互的一个缓存，并不是简单地丢弃旧的交互记录，而是将它们汇总成一份摘要，然后同时使用缓存与摘要。此外，它根据 Token 的使用长度而非交互次数来决定什么时候从缓存中移除旧的交互信息。

1
2
3
4
5
6
7

from langchain.memory import ConversationSummaryBufferMemory

memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})

memory.load_memory_variables({})

1

{'history': 'System: Current summary:\nThe human greets the AI. The AI responds with an informal greeting.
分发吧
关注
开源模型应用落地-LangChain高阶-记忆组件-ConversationBufferMemory正确使用（一）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
07-24 1万+
学习如何正确使用ConversationBufferMemory组件
使用 LangChain 从短暂记忆到持久记忆
2401_85233349的博客
07-23 961
详细介绍如何将简单的聊天机器人转变为具有长期记忆和上下文理解能力的复杂 AI 助手
记忆的力量：使用Langchain为AI助手添加持久记忆
08-24 1943
import ostry:# 定义一个函数来保存聊天历史到 Redis# 保存聊天历史到 Redis（使用 JSON）# 将 JSON 字符串中的汉字转换为 Base64 编码# 定义一个函数来从 Redis 获取聊天历史# 从 Redis 获取聊天历史（使用 JSON）# 用户的背景信息return "姓名：黑金;职务：从事IT开发10年;爱好：喜欢研究新代码"("system", "你是一个AI聊天助手"),
LangChain让LLM带上记忆
程序员半支烟，wechat：yclxiao
06-12 1664
最近两年，我们见识了“百模大战”，领略到了大型语言模型（LLM）的风采，但它们也存在一个显著的缺陷：没有记忆。在对话中，无法记住上下文的 LLM 常常会让用户感到困扰。本文探讨如何利用 LangChain，快速为 LLM 添加记忆能力，提升对话体验。LangChain 是 LLM 应用开发领域的最大社区和最重要的框架。
大模型从入门到应用——LangChain：记忆（Memory）-[基础知识]
冯·诺依曼
08-06 1万+
默认情况下，链（Chains）和代理（Agents）是无状态的，这意味着它们将每个传入的查询视为独立的（底层的LLM和聊天模型也是如此）。在某些应用程序中（如：聊天机器人），记住先前的交互则非常重要。记忆（Memory）正是为此而设计的。LangChain提供两种形式的记忆组件。首先，LangChain提供了用于管理和操作先前聊天消息的辅助工具，这些工具都被设计为模块化的使用方式。其次，LangChain提供了将这些工具轻松整合到链中的方法。记忆涉及了在用户与语言模型的交互过程中保持状态的概念。
LangChain之内存记忆 ( Memory )
2401_84495725的博客
06-14 991
ConversationSummaryMemory这种类型的记忆随着时间的推移创建对话的摘要。对话摘要记忆随着对话的发生而总结对话，并在记忆中存储当前的摘要。ConversationSummaryMemory这种记忆对于较长的对话最有用，可以避免过度使用Token，因为将过去的信息历史以原文形式保留在提示中会占用太多的Token。复制代码摘要对话：每次新的互动发生时对对话进行摘要，而不是保存完整的对话历史。使用LLM进行摘要：摘要功能由另一个LLM驱动，AI自行进行对话摘要。
LangChain 详细介绍及使用场景
热门推荐
weixin_40400410的博客
08-14 1万+
LangChain 是一个强大的框架，旨在帮助开发人员使用语言模型构建端到端的应用程序。它提供了一套工具、组件和接口，可简化创建由大型语言模型 （LLM） 和聊天模型提供支持的应用程序的过程。LangChain 可以轻松管理与语言模型的交互，将多个组件链接在一起，并集成额外的资源，例如 API 和数据库。中文文档：https://www.langchain.asia官方文档：https://python.langchain.com/docs/get_started/introductionModel。
Python—使用LangChain调用千帆大模型
qq_43548590的博客
01-11 8286
LangChain就是一个 LLM 编程框架，你想开发一个基于 LLM 应用，需要什么组件它都有，直接使用就行；甚至针对常规的应用流程，它利用链(LangChain中Chain的由来)这个概念已经内置标准化方案了。LangChain是一个用于开发由语言模型提供支持的应用程序的框架。数据感知：将语言模型连接到其他数据源具有代理性质：允许语言模型与其环境交互
使用Python和LangChain构建具有会话记忆的检索增强生成（RAG）应用的详细指南
m0_57781768的博客
06-27 381
RAG是一种技术，通过结合LLM的推理能力和外部数据源来增强模型的知识。虽然LLM可以处理广泛的话题，但它们的知识仅限于训练时使用的公开数据，且截至时间固定。如果希望构建能够处理私有数据或模型截止日期之后数据的AI应用，就需要通过RAG来增强模型的知识。这一过程通过检索相关信息并将其插入到模型的提示中来实现，从而提高回答的准确性和相关性。
使用 LangChain 创建高度互动和智能的聊天机器人
乘风之行
08-03 1110
随着自然语言处理（NLP）技术的进步，聊天机器人已成为企业和用户之间互动的重要渠道。LangChain 是一个强大的框架，旨在简化构建复杂语言模型应用程序的过程。本文将详细介绍如何使用 LangChain 框架创建高度互动和智能的聊天机器人，包括选择合适的语言模型、设计对话流程、上下文管理以及集成外部API和服务等内容。
【LangChain编程：从入门到实践】记忆组件类型
AI天才研究院
06-15 427
在对话式AI系统中，记忆（Memory）是一个至关重要的组件。它允许语言模型在多轮对话中保持上下文信息，使得对话更加自然、连贯。LangChain作为一个强大的自然语言处理框架，提供了多种记忆组件类型，方便开发者根据不同场景需求进行选择和使用。更加个性化和上下文相关的记忆模型结合知识图谱、本体等技术，实现更加智能的信息检索通过元学习等方法，让记忆模块具备自适应、自更新的能力隐私和数据安全问题记忆模块的可解释性和可控性如何平衡模型性能和计算资源消耗。
开源模型应用落地-LangChain高阶-记忆组件-ConversationEntityMemory正确使用（三）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
07-26 8426
如何正确使用ConversationEntityMemory组件
【大模型从入门到精通19】开源库框架LangChain LangChain文档加载器1
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
08-13 1289
在数据驱动的应用领域，特别是涉及对话界面和大型语言模型（LLM）的应用中，从各种来源高效加载、处理并与数据进行交互的能力至关重要。这些加载器擅长处理来自公共源的数据，如 YouTube、Twitter 和 Hacker News，同时也适用于来自专有源的数据，如 Figma 和 Notion。保存清洗后的文本：可选地，脚本可以将清洗和分词后的文档文本保存到文件中。这个扩展的代码提供了一个更全面的示例，展示如何从加载和清洗文本到基本分析和处理特殊情况，对 PDF 文档进行程序化的处理。
Day21包和模块
weixin_50199478的博客
10-30 605
一个.py文件就是一个模块。模块是含有一系列数据、函数、类等的程序。包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。包是一个包含一个特殊的__init__.py文件的目录。
01_IAR新建CC2530工程
nanxl1的博客
11-02 888
由于很多Zigbee商家提供的教程未有从零建立CC2530工程的讲解，可能会导致后面的开发中出现一些琐碎的问题。本文将以**LED流水灯**为例，从0到1用**IAR**建立CC2530工程。
cleanfid库的fid使用，及其使用CLIP模型clip_vit_b_32计算FID
最新发布
百年孤独百年的博客
11-02 710
这篇博客详细介绍了如何使用 cleanfid 库计算 Fréchet Inception Distance (FID)，特别是利用 CLIP 模型 clip_vit_b_32 计算 FID 分数来评估生成图像的质量。内容涵盖了 FID 的概念和原理、cleanfid 库的安装与配置、从缓存中加载与手动加载模型的方法，以及解决可能遇到的依赖问题。通过这篇教程，可以掌握使用 cleanfid 库计算fid的完整流程，并能够解决服务器环境中遇到的联网与模型下载问题。
Backtrader 数据篇 02
进击的小学生
10-30 1002
重新自定义数据读取函数，自定义的方式就是继承数据加载类 GenericCSVData、PandasData 再构建一个新的类，然后在新的类里统一设置参数。如果传递负值（例如：-1），则表示 CSV 数据中不存在该字段自定义的函数，不会修改 Backtrader 底层的数据表格内 lines 的排列规则。
变量与数据类型：从整数到字符串
redrose2100的博客
10-30 74
变量是用于存储数据的命名空间。在Python中，定义变量非常简单，你只需要将一个值赋给变量名即可。# 定义变量x = 10变量名只能包含字母、数字和下划线（_）。变量名不能以数字开头。变量名不能为Python的关键字（如ifelsewhile等）。# 合法的变量名age = 25# 非法的变量名# 1st_num = 10 # 不能以数字开头# if = "condition" # 不能使用Python关键字。
196.245.124.255.236.194.0.0.0.0.0.0.0.0.9 用python截取最后一个点后面的数据
qq_44534541的博客
10-30 138
这个方法从字符串的右边开始分割，并且可以指定分割的最大次数。在Python中，如果你想要截取字符串中最后一个点（，因为它是最后一个点后面的数据。这段代码会处理没有点的情况（）和点的后面不是数字的情况（）后面的数据，你可以使用。
langchain的记忆
04-25
很抱歉，我不了解"langchain"的记忆。"langchain"可能是一个特定的术语、项目或者公司名称，如果您能提供更多的背景信息，我可以尽力帮助您。以下是一些关于记忆的常见问题，希望对您有所帮助： 1. 什么是记忆？ 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值