1

//*[text()="Copy link to post"]  # 你甚至不能确定这个链接对应的标签是不是<a>

1
2

>>> from DrissionPage import ChromiumPage
>>> page = ChromiumPage()

1

>>> page.ele('x://button[@id="ember47"]').click()

1

//h5[@class="feed-shared-control-menu__headline t-14 t-black t-bold"]

1
2
3
4

**关于这个问题，我有以下看法**
* 第一点
* 第二点
* 第三点

1
2
3

import mistune

html = mistune.html('一段markdown')

1
2
3
4
5
6
7
8
9
10
11

...

def start_requests(self):
    yield scrapy.Request('https://baidu.com')

def parse(self, response):
    import pymongo
    handler = pymongo.MongoClient().xxdb.yycol
    rows = handler.find()
    for row in rows:
        yield row

1
2
3
4
5
6
7
8
9

def start_requests(self):
    yield scrapy.Request('data:,')

def parse(self, response):
    import pymongo
    handler = pymongo.MongoClient().xxdb.yycol
    rows = handler.find()
    for row in rows:
        yield row

1
2
3
4
5
6
7
8
9
10

def start_requests(self):
    while True:
        yield scrapy.Request('https://kingname.info/atom.xml', callback=self.parse, dont_filter=True)
        time.sleep(60)

def parse(self, response):
    ...对rss接口返回的数据进行处理...
    for item in xxx['items']:
        url = row['url']
        yield scrapy.Request(url, callback=self.parse_detail)

1
2
3
4
5
6
7
8
9
10
11
12
13

import asyncio


async def start_requests(self):
    while True:
        yield scrapy.Request('https://kingname.info/atom.xml', callback=self.parse, dont_filter=True)
        asyncio.sleep(60)

def parse(self, response):
    ...对rss接口返回的数据进行处理...
    for item in xxx['items']:
        url = row['url']
        yield scrapy.Request(url, callback=self.parse_detail)

1
2
3
4
5
6
7
8
9
10

def start_requests(self):
yield scrapy.Request('data:,', callback=self.make_really_req)

async def make_really_req(self, _):
while True:
yield scrapy.Request(url="https://kingname.com", callback=self.parse)
await asyncio.sleep(60)

def parse(self, response):
print(response.text)

1
2

@folder src/core/assistant-message
这是cline这个自动化编程copilot在收到大模型返回的信息以后，对信息进行处理的逻辑。请阅读它的代码并告诉我它的解析逻辑。

1

详细解释一下replace_in_file的具体逻辑和流程

1
2
3
4
5
6
7

现在，为了便于我的理解，请帮我实现一个replace_in_file 的Python版本。请在项目根目录创建一个example文件夹。这个文件夹里面有4个文件，分别为：

1. example_llm_response.txt：假设一段从大模型返回的内容
2. example_old.py：一段需要被修改的代码
3. replacer.py: Python版本的replace_in_file

当我运行replacer.py以后，它应该能够根据example_llm_response.txt中的内容，修改example_old.py，然后生成example_new.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我会帮你修复calculate_multiply函数中的bug。

<replace_in_file>
<diff>
<<<<<<< SEARCH
def calculate_multiply(a, b):
    # 这是一个有bug的乘法函数
    return a + b  # 这里错误地使用了加法
=======
def calculate_multiply(a, b):
    # 修复后的乘法函数
    return a * b  # 修正为正确的乘法运算
>>>>>>> REPLACE
</diff>
</replace_in_file>

现在乘法函数已经修复了，它会返回正确的结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def calculate_sum(a, b):
    # 计算两个数的和
    return a + b

def calculate_multiply(a, b):
    # 这是一个有bug的乘法函数
    return a + b  # 这里错误地使用了加法

def greet(name):
    # 打招呼函数
    print("Hello " + name)

if __name__ == "__main__":
    result = calculate_multiply(3, 4)
    print(f"3 x 4 = {result}")  # 这里会输出错误结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from zhipuai import ZhipuAI
client = ZhipuAI(api_key="") # 填写您自己的APIKey
response = client.chat.completions.create(
    model="glm-4-air-0111",
    messages=[
        {"role": "system", "content": '''你是一个数据提取专家，非常善于从
从长文本中，提取结构化的数据。
        '''},
        {"role": "user", "content": '''你需要从下面的文本中，提取出姓名，工资，地址，然后以JSON格式返回。返回字段示例：{"name": "xxx", "salary": "yyy", "address": "zzz"}.只需要返回JSON字符串就可以了，不要解释，不要返回无关的内容。

"""
长文本
"""
'''}
    ],
)
print(response.choices[0].message)

1
2
3
4
5
6
7
8
9

……上面是一大堆描述……

返回的字段必须按如下示例返回：

{
"floor_area": 100,
"building_area": 899
...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import instructor
from pydantic import BaseModel
from openai import OpenAI

# Define your desired output structure
class ExtractUser(BaseModel):
    name: str
    age: int

# Patch the OpenAI client
client = instructor.from_openai(OpenAI())

# Extract structured data from natural language
res = client.chat.completions.create(
    model="gpt-4o-mini",
    response_model=ExtractUser,
    messages=[{"role": "user", "content": "John Doe is 30 years old."}],
)

assert res.name == "John Doe"
assert res.age == 30

1

pip install 'instructor[litellm]'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import instructor
from litellm import completion
client = instructor.from_litellm(completion)
resp = client.chat.completions.create(
    model="openai/glm-4-air-0111",
    api_key="对应的API Key",
    api_base="https://open.bigmodel.cn/api/paas/v4/",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": html,
        }
    ],
    response_model=HouseInfo,
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from pydantic import BaseModel, Field

class HouseInfo(BaseModel):
    floor_area: int = Field(description="占地面积")
    building_area: int = Field(description="建筑面积")
    plot_ratio: int = Field(description="容积率")
    greening_rate: int = Field(description="绿化率")
    total_buildings: int = Field(description="楼栋总数")
    total_households: int = Field(description="总户数")
    property_management_company: str = Field(description="物业公司")
    property_management_fee: str = Field(description="物业费")
    property_management_fee_description: str = Field(description="物业费描述")
    parking_spaces: str = Field(description="停车位")
    parking_space_description: str = Field(description="停车位描述")
    floor_status: str = Field(description="楼层状况")

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
28
29
30
31
32
33
34
35
36
37
38
39
40

import instructor
from litellm import completion
from pydantic import BaseModel, Field

class HouseInfo(BaseModel):
    floor_area: int = Field(description="占地面积")
    building_area: int = Field(description="建筑面积")
    plot_ratio: int = Field(description="容积率")
    greening_rate: int = Field(description="绿化率")
    total_buildings: int = Field(description="楼栋总数")
    total_households: int = Field(description="总户数")
    property_management_company: str = Field(description="物业公司")
    property_management_fee: str = Field(description="物业费")
    property_management_fee_description: str = Field(description="物业费描述")
    parking_spaces: str = Field(description="停车位")
    parking_space_description: str = Field(description="停车位描述")
    floor_status: str = Field(description="楼层状况")

client = instructor.from_litellm(completion)

html = '''
精简以后的HTML代码
'''

resp = client.chat.completions.create(
    model="openai/glm-4-air-0111",
    api_key="你的API Key",
    api_base="https://open.bigmodel.cn/api/paas/v4/",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": html,
        }
    ],
    response_model=HouseInfo,
)

print(resp.model_dump_json(indent=2))
print(f'提取到的占地面积是：{resp.floor_area}')

1
2
3
4
5
6
7

你是一个数据提取专家，你能从一段文本中提取出所有结构化数据。并以J50N格式返回。返回格式示例:

{
"name": "小王",
"age": 27,
"salary": 999
}

1
2
3
4
5
6
7
8
9

你是一个资深的文学家，你正在阅读一篇关于大模型的文章，请仔细阅读，然后基于文章的内容，回答三个问题：

* 什么是大模型？
* 为什么需要大模型？
* 怎么使用大模型？

下面是文章的原文：

{article}

1
2
3
4
5
6
7

第一段...

第二段...

中间很多文字

看完上面这篇文章以后，请分享一下你对大模型的观点和看法。

1
2
3
4
5
6
7
8
9
10
11
12

<role>你是一个资深的文学家</role>
<task>你正在阅读一篇关于大模型的文章，请仔细阅读，然后基于文章的内容，回答三个问题：
<questions>
<question>什么是大模型？</question>
<question>为什么需要大模型？</question>
<question>怎么使用大模型？</question>
</questions>
</task>

<article>
{article}
</article>

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

你是一个资深的文学家，你正在阅读一篇文章，请仔细阅读，然后基于文章的内容，按如下格式返回总结：

## 文章概览

[对文章的整体总结]

## 核心观点

* 观点1
* 观点2
* 观点n

## 关键人物

如果文章中提到了金融领域的任何人物，需要把他们提取出来，如果没有，就忽略这一项

## 规则

在总结的时候，你必须遵守如下规则：

1. 如果文章与金融领域无关，直接回复『非金融文章不用总结』
2. 如果文章涉及到大模型，请在文章概览的头部加上【大模型】标记
3. ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

## 文章概览

...

## 核心观点

...

## 关键人物

...

## 规则

...

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

<role>你是一个资深的文学家，你正在阅读一篇文章</role>
<task>请仔细阅读，然后基于文章的内容，按如下格式返回总结：
<response_format>
## 文章概览

[对文章的整体总结]

## 核心观点

* 观点1
* 观点2
* 观点n

## 关键人物

如果文章中提到了金融领域的任何人物，需要把他们提取出来，如果没有，就忽略这一项
</response_format>
</task>
<rule>
## 规则

在总结的时候，你必须遵守如下规则：

1. 如果文章与金融领域无关，直接回复『非金融文章不用总结』
2. 如果文章涉及到大模型，请在文章概览的头部加上【大模型】标记
3. ...
</rule>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<role>你是一个金融领域的专家，拥有丰富的投资经验</role>
<task>请阅读下面10篇文章，并根据文章内容回答用户的问题
<articles>
<article id='1'>文章正文</article>
<article id='2'>文章正文</article>
<article id='3'>文章正文</article>
...
<article id='10'>文章正文</article>
</articles>
</task>
<rule>
...
5. 你的回答必须基于上面的10篇文章，在回答时，要说明每一句话来自哪一篇文章。你需要在句子的末尾，标记[id]
...
</rule>
<question>用户的问题</question>

1
2

from openai.lib.azure import AzureOpenAI
client = AzureOpenAI(api_key=..., azure_endpoint=..., api_version=...)

1
2
3

git clone git@github.com:kennethreitz/simplemind.git
cd simplemind
pip install -e .

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

from .openai import OpenAI
import os
from functools import cached_property

class AzureOpenAI(OpenAI):
    NAME = 'azure_openai'
    def __init__(self, api_key: str | None = None):
        super().__init__(api_key=api_key)
        self.api_key = os.getenv('OPENAI_API_KEY')
        self.azure_endpoint='你的AzureGPT的url'
        self.api_version = '2024-07-01-preview'


    @cached_property
    def client(self):
        """The raw OpenAI client."""
        if not self.api_key:
            raise ValueError("OpenAI API key is required")
        try:
            from openai.lib.azure import AzureOpenAI
        except ImportError as exc:
            raise ImportError(
                "Please install the `openai` package: `pip install openai`"
            ) from exc
        return AzureOpenAI(api_key=self.api_key, azure_endpoint=self.azure_endpoint, api_version=self.api_version)

1
2
3
4
5
6
7
8

import simplemind as sm
from dotenv import load_dotenv


load_dotenv()

resp = sm.generate_text(prompt='太阳为什么是圆的？', llm_model='gpt-4o-mini', llm_provider='azure_openai')
print(resp)

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

def make_sound(animal):
    sound = animal.bark()
    print(f'这个动物在{sound}')


class Duck:
    def bark(self):
        return '嘎嘎叫'


class Dog:
    def bark(self):
        return '汪汪叫'


class Cat:
    def bark(self):
        return '喵喵叫'


small_cat = Cat()
make_sound(small_cat)

1
2
3
4
5
6
7
8

# 首先通过环境变量设置大模型的参数

import simplemind as sm

conv = sm.create_conversation()
conv.add_message("user", "Hi there, how are you?")
resp = conv.send()

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

class SimpleMemoryPlugin(sm.BasePlugin):
    def __init__(self):
        self.memories = [
            "the earth has fictionally beeen destroyed.",
            "the moon is made of cheese.",
        ]

    def yield_memories(self):
        return (m for m in self.memories)

    def pre_send_hook(self, conversation: sm.Conversation):
        for m in self.yield_memories():
            conversation.add_message(role="system", text=m)


conversation = sm.create_conversation()
conversation.add_plugin(SimpleMemoryPlugin())


conversation.add_message(
    role="user",
    text="Please write a poem about the moon",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def get_weather(
    location: Annotated[
        str, Field(description="The city and state, e.g. San Francisco, CA")
    ],
    unit: Annotated[
        Literal["celcius", "fahrenheit"],
        Field(
            description="The unit of temperature, either 'celsius' or 'fahrenheit'"
        ),
    ] = "celcius",
):
    """
    Get the current weather in a given location
    """
    return f"42 {unit}"

# Add your function as a tool
conversation = sm.create_conversation()
conversation.add_message("user", "What's the weather in San Francisco?")
response = conversation.send(tools=[get_weather])

1
2
3
4
5
6
7

def rag_ask(question):
    question_embedding = text2embedding(question)
    chunks = query_vector_db(question_embedding)
    clean_chunks = my_logic_to_clean_chunks(chunks)
    sorted_chunks = rerank(clean_chunks)
    prompt = '使用sorted_chunks和question构造出rag的prompt'
    answer = ask_llm(prompt)

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

你将扮演一个HTML解析器的角色。我将会提供一段HTML代码，这段代码可能代表了一个博客网站的文章列表页或者文章详情页。你需要首先判断这段HTML是属于哪种类型的页面。如果是文章详情页，那么页面中通常会包含文章标题、发布时间、作者以及内容等信息；而如果是列表页，则会列出多篇文章的标题及其对应的详情页链接。

请根据以下规则进行处理：

1. 分析提供的HTML代码，确定页面类型（`list` 或 `detail`）。
2. 根据页面类型，提取必要的信息：
   - 如果是列表页，请找到所有文章条目，并为每个条目提供标题和指向详情页的链接。
   - 如果是详情页，请找到文章标题、作者、发布时间和内容的XPath。确保XPath直接指向包含这些信息的具体元素值，例如使用`@属性`或者`text()`来获取确切的文本内容。
3. 尽量使用具有特征性的属性如`id`或`class`来构造XPath，以确保XPath简洁且鲁棒。
4. 对于标题、作者、发布时间等字段，如果它们不是直接在某个标签内，而是嵌套在其他标签中，XPath应包括这些结构，以保证准确性。
5. 按照指定格式输出结果。
6. 只需要返回JSON，不要解释，不要返回无关内容

**输出格式：**

- 对于列表页，返回如下JSON结构：
  \`\`\`json
  {
      "page_type": "list",
      "articles": [
          {"title": "文章标题", "url": "文章详情页URL"},
          {"title": "文章标题", "url": "文章详情页URL"},
          {"title": "文章标题", "url": "文章详情页URL"},
          // 更多文章...
      ]
  }
  \`\`\`

- 对于详情页，返回如下JSON结构：
  \`\`\`json
  {
      "page_type": "detail",
      "fields": [
          {"field_name": "title", "xpath": "XPath to the title"},
          {"field_name": "author", "xpath": "XPath to the author"},
          {"field_name": "publish_time", "xpath": "XPath to the publish time"},
          {"field_name": "content", "xpath": "XPath to the content"}
      ]
  }
  \`\`\`

现在，请接收以下HTML代码并开始分析：

1
2
3
4
5
6
7
8
9
10
11
12
13

你将扮演一个HTML解析器的角色。我将会提供一段HTML代码，这段代码可能代表了一个博客网站的文章列表页。你需要找到页面上的翻页链接，并提取出下一页的URL  
  
请根据以下规则进行处理：  
  
1. 分析提供的HTML代码，找到翻页按钮。  
2. 翻页按钮上面的文本可能是『下一页』、『next』、『>』、『Load more』等，也可能是一个数字，代表页码，也可能是paging标签或者classname包含pagination的某个标签。没有固定的标准，你需要智能识别  
3. 返回下一页的URL，如果没有下一页，返回空字符串  
4. 按照指定格式输出结果。  
5. 只需要返回JSON，不要解释，不要返回无关内容  
  
返回JSON格式：  
  
{"page_type": "paging", "url": "下一页的url"}

1

pyarmor g -e 30 json_path_finder.py

1

pyarmor g -e 2024-08-30 json_path_finder.py

1
2

pyarmor cfg nts=pool.ntp.org
pyarmor g -e 2024-08-30 json_path_finder.py

1

pyarmor g -b <mac地址> json_path_finder.py

1
2

pyarmor g -b 128.16.4.10 foo.py
pyarmor g -b HXS2000CN2A foo.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

llm:
  model: "deepseek-chat"
  temperature: 0
  api_key: <你的API KEY>  # Your API key, if the API requires it
  api_base: https://api.deepseek.com  # The URL where an OpenAI-compatible server is running to handle LLM API requests
  # api_version: ...  # The version of the API (this is primarily for Azure)
  max_output: 4096  # The maximum characters of code output visible to the LLM
  
# Computer Settings
computer:
  import_computer_api: True # Gives OI a helpful Computer API designed for code interpreting language models


multi_line: True # If True, you can input multiple lines starting and ending with ```

version: 0.2.5  # Profile version (do not modify)

1

读取/Users/kingname/Downloads/xiaohongshu.har 这个文件，然后找到url中包含/api/sns/web/v1/homefeed的请求，接下来，使用json.loads加载返回的内容。注意返回的内容可能直接是JSON字符串，也可能是base64字符串，你需要判断。如果发现是base64，需要先解码。然后再使用json.loads加载。读取.data.items列表，对这个列表进行迭代，如果每一项的model_type字段不为note，跳过。如果是note，那么就读取note_card.display_title字段，把结果打印出来。

1
2
3
4
5
6
7

import interpreter

interpreter.chat('读取/Users/kingname/Downloads/xiaohongshu.har 这个文件，然后找到url中包含/api/sns/web/v1/homefeed的请求，接下来，使用json.loads加载返回的内容。注意返回的内容可能直接是JSON字符串，也可能是base64字符串，你需要判断。如果发现是base64，需要先解码。然后再使用json.loads加载。读取.data.items列表，对这个列表进行迭代，如果每一项的model_type字段不为note，跳过。如果是note，那么就读取note_card.display_title字段，把结果写入到note_title.txt文件中')

with open('note_title.txt') as f:
    for line in f:
        print('接下来就可以用结果做其他Python操作了')

1

访问https://kingname.info/，使用lxml执行xpath： //a[@class="post-title-link"]/@href获取每篇文章的url。然后逐一进入每一篇文章的详情页，使用//h1[@class="post-title"]/text()获取标题，使用//time[@itemprop="dateCreated datePublished"]/text获取发布时间，使用//div[@itemprop="articleBody"]/p//text()获取正文。然后把这些数据保存到article.txt文件中。每篇文章之间 使用==========分割

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def bot(text):
summary = summary_text_by_gpt(text)
qa = get_qa_by_gpt(text)

output = '''
## 文本总结

{summary}

## 核心问答

{qa}
'''
return output

1
2
3
4
5
6
7
8
9
10
11
12
13

import json

text = '''## 摘要
这篇文章主要包含xx和yy

## 详情
1. abc
2. def
'''

item = {'title': '关于abc', 'raw': text}
output = json.dumps(item, ensure_ascii=False)
print(output)

1

{"title": "关于abc", "raw": "## 摘要\n这篇文章主要包含xx和yy\n\n## 详情\n1. abc\n2. def\n"}

1

npx create-next-app test_cors

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

import { NextResponse } from 'next/server'


export const config = {
    runtime: "edge"
}

export interface UserInfo {
    name: string
    age: number
    address: string
}


const handler = async (req: Request): Promise<Response> => {
    
    const user = (await req.json()) as UserInfo
    return NextResponse.json({success: true,
                              msg: `你的名字是${user.name}, 今年${user.age}岁`})
}

export default handler;

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>API 请求示例</title>
    <script>
        // 当按钮被点击时执行此函数
        function sendRequest() {
            // 创建一个新的 XMLHttpRequest 对象
            var xhr = new XMLHttpRequest();

            // 配置请求类型、URL 以及异步处理
            xhr.open('POST', 'http://127.0.0.1:3000/api/test', true);

            // 设置请求头
            xhr.setRequestHeader('Content-Type', 'application/json');
            // ... 其他请求头设置

            // 设置响应类型
            xhr.responseType = 'json';

            // 定义请求完成的回调函数
            xhr.onload = function () {
                if (xhr.status === 200) {
                    // 请求成功，处理响应数据
                    document.getElementById('response').innerText = JSON.stringify(xhr.response);
                } else {
                    // 请求失败，处理错误
                    document.getElementById('response').innerText = '请求失败: ' + xhr.status;
                }
            };

            // 发送请求
            xhr.send(JSON.stringify({name: "青南", age: 20, "address": "上海"}));
        }
    </script>
</head>
<body>
    <button onclick="sendRequest()">发送请求</button>
    <div id="response"></div>
</body>
</html>

1
2
3

if(req.method === 'OPTIONS') {
    return NextResponse.next()
}

1
2
3
4
5

你是一个数据提取小助手，能够从一大段招聘相关的文本中提取有用的信息并以JSON格式返回。

{经过清洗的网页源代码或者文本}

请从上面的文本中，提取招聘相关的信息，返回数据格式如下： {"title": "岗位名称", "full_time": "是否为全职", "employee_num": "雇员数量", "level": "岗位等级", "skill": "岗位需要的技能", "desc": "岗位描述", "company": "公司介绍", "do": "岗位具体做什么事情", "requirement": "岗位要求", "goodpoint": "优先录取条件"}

1
2

USELESS_TAG = ['style', 'script', 'link', 'video', 'iframe', 'source', 'picture', 'header', 'blockquote',  
               'footer', 'code']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

USELESS_ATTR = {  
                'share',  
                'contribution',  
                'copyright',  
                'copy-right',  
                'disclaimer',  
                'recommend',  
                'related',  
                'footer',  
                'comment',  
                'social',  
                'submeta',  
                'report-infor',  
                "auto_modal"  
                }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import requests
import json

url = "https://crawler.kingname.info/gne/crawl"

body = {
  "url": "https://www.kingname.info/2023/10/17/rubbish/",
  "js": False,
  "charset": "auto"
}

headers = {
  'token': '<TOKEN>',
}

response = requests.post(url, headers=headers, json=body)

response.json()

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

{'title': '拒绝成为这样的程序员',
 'publish_time_ts': 1697545236,
 'publish_time': '2023-10-17 12:20:36',
 'content': '产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。 正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。 借此机会，我准备用几篇文章来讲讲自己的经验和个人的观点。 有这样一批人，他们在大公司里工作了十几年，年龄一大把，还是一个大头兵。他们被号称经验丰富，但实际上是把一年的工作经验用了十多年，对主流的技术一无所知，他们已经无法适应现在的技术发展。 这些人，每天看起来非常努力，加班加到很晚。产品经理提需求，他们看起来是在非常努力的完成，但完成的效果非常差。产品给他们提修改意见，他们看起来非常积极地去修改。但是改了A问题，出现B问题，改了B问题，出现C问题，修好C问题，A问题又出现了…… 产品经理每次一说产出效果不好，他们马上就会蹦出一大堆技术名词，又是什么业界难题，又是什么行业边界，又是什么技术翘翘板，把A改了，那么从理论上说B就一定有问题。ABC三个需求无法同时满足。言语之间时不时蹦出一些他们昨天刷公众号看到的技术名词。但其实真正的原因是这个需求达到了他们知识的边界，而他们又不愿意学习。他们花3个月做出来的东西，换一个应届生2天就能完成，而且效果好十倍。 这些人，永远把自己当作一个螺丝钉。产品需要什么，自己就做什么。产品不说的，自己坚决不做。产品找过来，一句“你又没有说要这个功能”就把自己的责任推卸干净。 当任务涉及到多个人协作时，这些人把自己的活干完就跑了。从来不会通知一下上下游的同事。等到项目预计上线的前一晚，产品经理来问： “你这个功能做完了吗？” “做完了。” “那调试好了吗？” “我不知道上游的xx和下游的yy他们做完了没有。” 这样的人，我称之为老油条。 老油条特别喜欢装无辜，我都已经这么努力了，你还想怎么样？然后在线上线下宣传自己被公司压榨，被同事排挤，被老员工PUA.但真实的情况是，公司只让他在做这一件事情，他做了三个月。每一次效果不好，其他人都在陪着他分析原因，等他修改。改完以后效果更差。大家给他一次又一次机会，上线时间为他一次又一次推迟，他一次又一次让大家失望。每次还都会找各种理由各种借口。 很多人希望公司能够开除他，但是老板有顾虑，公司有担忧。不敢开除，甚至不敢给他打低绩效。公司，特别是大公司，非常害怕他们在网上发帖。 弱小不一定有理，弱小只是某些老油条的遮羞布。 我觉得现在互联网环境的风气极差。正适合这些老油条肆意妄为。 当一个人在网上发帖说自己被公司开除了，一大批不知道任何内情的网民就会开始攻击公司，觉得这个人太可怜，觉得这个公司太黑毫无人性。特别是当公司是某些著名大厂时，这种攻击更是毫不留情。 民众总是相信弱小者的哭诉，从来听不见强者背后的辩解。知情人为公司解释两句，一大群人站出来要为弱小着主持公道：你是资本的走狗，你是五毛党，你收了多少钱。 正是这样的老油条，导致开除一个人的成本非常高，公司迫于不想惹麻烦，很多时候对于能力差的人选择睁一只眼闭一只眼。现在大环境降本增效，去肥增瘦，能力差的老油条占住了坑位，就会导致真正有能力的人失去一个又一个进入大厂的机会。 几个大厂里面，有很多很多这样的老油条。看这篇文章的你，本来有机会进大厂一展才华，但都是因为这些老油条占住了人头，导致对应的岗位不再招人。其实你比他更加适合这个岗位，但没办法。 公司没有办法开掉这些人，因为现在舆论的风暴太猛。这些风暴始于老油条的装可怜，加强于键盘党的假公道，盛行于跟风人的瞎同情。 没有办法，真的没办法。 每当产品经理跟我讲起他们公司里面的老油条，我都恨不能当场掀桌，但没办法，我吵架超不过，大架也打不过。赢了坐牢，输了住院。 没办法，真的没办法。 只盼大家擦亮眼睛，在同情某些被劝退的互联网员工前，别急着站队，先想想这个人是不是占了本该属于你的岗位。 抱怨归抱怨，希望大家不要成为这样的人。我们下一篇文章，来讲讲我们应该如何成为一个不会被年龄所限制的优秀工程师。',
 'clean_content': '<div><p>产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。</p><p>正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。</p><p>借此机会，我准备用几篇文章来讲讲自己的经验和个人的观点。</p><p>有这样一批人，他们在大公司里工作了十几年，年龄一大把，还是一个大头兵。他们被号称经验丰富，但实际上是把一年的工作经验用了十多年，对主流的技术一无所知，他们已经无法适应现在的技术发展。</p><p>这些人，每天看起来非常努力，加班加到很晚。产品经理提需求，他们看起来是在非常努力的完成，但完成的效果非常差。产品给他们提修改意见，他们看起来非常积极地去修改。但是改了A问题，出现B问题，改了B问题，出现C问题，修好C问题，A问题又出现了……</p><p>产品经理每次一说产出效果不好，他们马上就会蹦出一大堆技术名词，又是什么业界难题，又是什么行业边界，又是什么技术翘翘板，把A改了，那么从理论上说B就一定有问题。ABC三个需求无法同时满足。言语之间时不时蹦出一些他们昨天刷公众号看到的技术名词。但其实真正的原因是这个需求达到了他们知识的边界，而他们又不愿意学习。他们花3个月做出来的东西，换一个应届生2天就能完成，而且效果好十倍。</p><p>这些人，永远把自己当作一个螺丝钉。产品需要什么，自己就做什么。产品不说的，自己坚决不做。产品找过来，一句“你又没有说要这个功能”就把自己的责任推卸干净。</p><p>当任务涉及到多个人协作时，这些人把自己的活干完就跑了。从来不会通知一下上下游的同事。等到项目预计上线的前一晚，产品经理来问：</p><blockquote><p>“你这个功能做完了吗？”</p><p>“做完了。”</p><p>“那调试好了吗？”</p><p>“我不知道上游的xx和下游的yy他们做完了没有。”</p></blockquote><p>这样的人，我称之为老油条。</p><p>老油条特别喜欢装无辜，我都已经这么努力了，你还想怎么样？然后在线上线下宣传自己被公司压榨，被同事排挤，被老员工PUA.但真实的情况是，公司只让他在做这一件事情，他做了三个月。每一次效果不好，其他人都在陪着他分析原因，等他修改。改完以后效果更差。大家给他一次又一次机会，上线时间为他一次又一次推迟，他一次又一次让大家失望。每次还都会找各种理由各种借口。</p><p>很多人希望公司能够开除他，但是老板有顾虑，公司有担忧。不敢开除，甚至不敢给他打低绩效。公司，特别是大公司，非常害怕他们在网上发帖。</p><p>弱小不一定有理，弱小只是某些老油条的遮羞布。</p><p>我觉得现在互联网环境的风气极差。正适合这些老油条肆意妄为。</p><p>当一个人在网上发帖说自己被公司开除了，一大批不知道任何内情的网民就会开始攻击公司，觉得这个人太可怜，觉得这个公司太黑毫无人性。特别是当公司是某些著名大厂时，这种攻击更是毫不留情。</p><p>民众总是相信弱小者的哭诉，从来听不见强者背后的辩解。知情人为公司解释两句，一大群人站出来要为弱小着主持公道：你是资本的走狗，你是五毛党，你收了多少钱。</p><p>正是这样的老油条，导致开除一个人的成本非常高，公司迫于不想惹麻烦，很多时候对于能力差的人选择睁一只眼闭一只眼。现在大环境降本增效，去肥增瘦，能力差的老油条占住了坑位，就会导致真正有能力的人失去一个又一个进入大厂的机会。</p><p>几个大厂里面，有很多很多这样的老油条。看这篇文章的你，本来有机会进大厂一展才华，但都是因为这些老油条占住了人头，导致对应的岗位不再招人。其实你比他更加适合这个岗位，但没办法。</p><p>公司没有办法开掉这些人，因为现在舆论的风暴太猛。这些风暴始于老油条的装可怜，加强于键盘党的假公道，盛行于跟风人的瞎同情。</p><p>没有办法，真的没办法。</p><p>每当产品经理跟我讲起他们公司里面的老油条，我都恨不能当场掀桌，但没办法，我吵架超不过，大架也打不过。赢了坐牢，输了住院。</p><p>没办法，真的没办法。</p><p>只盼大家擦亮眼睛，在同情某些被劝退的互联网员工前，别急着站队，先想想这个人是不是占了本该属于你的岗位。</p><p>抱怨归抱怨，希望大家不要成为这样的人。我们下一篇文章，来讲讲我们应该如何成为一个不会被年龄所限制的优秀工程师。</p></div>',
 'content_list': [{'type': 'text',
   'data': '产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。',
   'caption': ''},
  {'type': 'text',
   'data': '正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。',
   'caption': ''},
  {'type': 'text', 'data': '借此机会，我准备用几篇文章来讲讲自己的经验和个人的观点。', 'caption': ''},
  {'type': 'text',
   'data': '有这样一批人，他们在大公司里工作了十几年，年龄一大把，还是一个大头兵。他们被号称经验丰富，但实际上是把一年的工作经验用了十多年，对主流的技术一无所知，他们已经无法适应现在的技术发展。',
   'caption': ''},
  {'type': 'text',
   'data': '这些人，每天看起来非常努力，加班加到很晚。产品经理提需求，他们看起来是在非常努力的完成，但完成的效果非常差。产品给他们提修改意见，他们看起来非常积极地去修改。但是改了A问题，出现B问题，改了B问题，出现C问题，修好C问题，A问题又出现了……',
   'caption': ''},
  {'type': 'text',
   'data': '产品经理每次一说产出效果不好，他们马上就会蹦出一大堆技术名词，又是什么业界难题，又是什么行业边界，又是什么技术翘翘板，把A改了，那么从理论上说B就一定有问题。ABC三个需求无法同时满足。言语之间时不时蹦出一些他们昨天刷公众号看到的技术名词。但其实真正的原因是这个需求达到了他们知识的边界，而他们又不愿意学习。他们花3个月做出来的东西，换一个应届生2天就能完成，而且效果好十倍。',
   'caption': ''},
  {'type': 'text',
   'data': '这些人，永远把自己当作一个螺丝钉。产品需要什么，自己就做什么。产品不说的，自己坚决不做。产品找过来，一句“你又没有说要这个功能”就把自己的责任推卸干净。',
   'caption': ''},
  {'type': 'text',
   'data': '当任务涉及到多个人协作时，这些人把自己的活干完就跑了。从来不会通知一下上下游的同事。等到项目预计上线的前一晚，产品经理来问：',
   'caption': ''},
  {'type': 'text', 'data': '“你这个功能做完了吗？”', 'caption': ''},
  {'type': 'text', 'data': '“做完了。”', 'caption': ''},
  {'type': 'text', 'data': '“那调试好了吗？”', 'caption': ''},
  {'type': 'text', 'data': '“我不知道上游的xx和下游的yy他们做完了没有。”', 'caption': ''},
  {'type': 'text', 'data': '这样的人，我称之为老油条。', 'caption': ''},
  {'type': 'text',
   'data': '老油条特别喜欢装无辜，我都已经这么努力了，你还想怎么样？然后在线上线下宣传自己被公司压榨，被同事排挤，被老员工PUA.但真实的情况是，公司只让他在做这一件事情，他做了三个月。每一次效果不好，其他人都在陪着他分析原因，等他修改。改完以后效果更差。大家给他一次又一次机会，上线时间为他一次又一次推迟，他一次又一次让大家失望。每次还都会找各种理由各种借口。',
   'caption': ''},
  {'type': 'text',
   'data': '很多人希望公司能够开除他，但是老板有顾虑，公司有担忧。不敢开除，甚至不敢给他打低绩效。公司，特别是大公司，非常害怕他们在网上发帖。',
   'caption': ''},
  {'type': 'text', 'data': '弱小不一定有理，弱小只是某些老油条的遮羞布。', 'caption': ''},
  {'type': 'text', 'data': '我觉得现在互联网环境的风气极差。正适合这些老油条肆意妄为。', 'caption': ''},
  {'type': 'text',
   'data': '当一个人在网上发帖说自己被公司开除了，一大批不知道任何内情的网民就会开始攻击公司，觉得这个人太可怜，觉得这个公司太黑毫无人性。特别是当公司是某些著名大厂时，这种攻击更是毫不留情。',
   'caption': ''},
  {'type': 'text',
   'data': '民众总是相信弱小者的哭诉，从来听不见强者背后的辩解。知情人为公司解释两句，一大群人站出来要为弱小着主持公道：你是资本的走狗，你是五毛党，你收了多少钱。',
   'caption': ''},
  {'type': 'text',
   'data': '正是这样的老油条，导致开除一个人的成本非常高，公司迫于不想惹麻烦，很多时候对于能力差的人选择睁一只眼闭一只眼。现在大环境降本增效，去肥增瘦，能力差的老油条占住了坑位，就会导致真正有能力的人失去一个又一个进入大厂的机会。',
   'caption': ''},
  {'type': 'text',
   'data': '几个大厂里面，有很多很多这样的老油条。看这篇文章的你，本来有机会进大厂一展才华，但都是因为这些老油条占住了人头，导致对应的岗位不再招人。其实你比他更加适合这个岗位，但没办法。',
   'caption': ''},
  {'type': 'text',
   'data': '公司没有办法开掉这些人，因为现在舆论的风暴太猛。这些风暴始于老油条的装可怜，加强于键盘党的假公道，盛行于跟风人的瞎同情。',
   'caption': ''},
  {'type': 'text', 'data': '没有办法，真的没办法。', 'caption': ''},
  {'type': 'text',
   'data': '每当产品经理跟我讲起他们公司里面的老油条，我都恨不能当场掀桌，但没办法，我吵架超不过，大架也打不过。赢了坐牢，输了住院。',
   'caption': ''},
  {'type': 'text', 'data': '没办法，真的没办法。', 'caption': ''},
  {'type': 'text',
   'data': '只盼大家擦亮眼睛，在同情某些被劝退的互联网员工前，别急着站队，先想想这个人是不是占了本该属于你的岗位。',
   'caption': ''},
  {'type': 'text',
   'data': '抱怨归抱怨，希望大家不要成为这样的人。我们下一篇文章，来讲讲我们应该如何成为一个不会被年龄所限制的优秀工程师。',
   'caption': ''}],
 'summary': '产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。. 正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。',
 'canonical_url': 'https://www.kingname.info/2023/10/17/rubbish/',
 'image_count': 0,
 'image_urls': [],
 'image_captions': [],
 'head_meta': {'og:description': '产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。 正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。 借此机会，我准备用几篇文章来讲讲自己的经验和个人的观点。',
  'description': '产品经理这两天在跟我抱怨他们公司的一个码农。听的我火冒三丈，差点把跟了我十多年的搪瓷水杯砸烂。 正好在知识星球和微信群里面，有不少同学跟我咨询程序员的职业发展以及怎么应对三十岁危机。 借此机会，我准备用几篇文章来讲讲自己的经验和个人的观点。',
  'og:type': 'article',
  'viewport': 'width=device-width',
  'article:tag': '开发经验',
  'generator': 'Hexo 6.2.0',
  'og:site_name': '谢乾坤 | Kingname',
  'article:author': '青南',
  'theme-color': '#222',
  'article:published_time': '2023-10-17T12:20:36.000Z',
  'og:locale': 'zh_CN',
  'og:url': 'https://www.kingname.info/2023/10/17/rubbish/index.html',
  'og:title': '拒绝成为这样的程序员',
  'article:modified_time': '2023-10-17T12:21:20.216Z',
  'twitter:card': 'summary'},
 'author': [],
 'timezone': 'UTC8',
 'url': 'https://www.kingname.info/2023/10/17/rubbish/',
 'amp_url': '',
 'breadcrumb': []}

1
2
3
4

 {
    "success": false,
    "msg": "解析正文失败！"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 import requests
import json

url = "https://crawler.kingname.info/gne/crawl"

body = {
  "url": "https://mp.weixin.qq.com/s/VObN8Ve8piv_I13fKbWhww",
  "js": True,
  "charset": "auto"
}

headers = {
  'token': '<TOKEN>',
}

response = requests.post(url, headers=headers, json=body)

response.json()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 import requests
import json

url = "https://crawler.kingname.info/gne/crawl"

body = {
  "url": "https://www.kingname.info/archives/",
  "js": false,
  "charset": "auto",
  "target": "link"
}

headers = {
  'token': '<TOKEN>',
}

response = requests.post(url, headers=headers, json=body)

response.json()

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
28
29
30

[{'url': 'https://www.kingname.info/', 'anchor': '谢乾坤 | Kingname'},
{'url': 'https://www.kingname.info/archives/', 'anchor': '归档'},
{'url': 'https://www.kingname.info/tags', 'anchor': '标签'},
{'url': 'https://www.kingname.info/mp', 'anchor': '公众号'},
{'url': 'https://www.kingname.info/about', 'anchor': '关于'},
{'url': 'https://github.com/kingname', 'anchor': 'GitHub'},
{'url': 'https://www.kingname.info/2023/11/29/jwt/',
 'anchor': '一日一技：分布式系统的低成本权限校验机制'},
{'url': 'https://www.kingname.info/2023/11/15/git-worktree/',
 'anchor': '一日一技：如何同时在多个分支写代码？'},
{'url': 'https://www.kingname.info/2023/11/14/typeddict/',
 'anchor': '一日一技：警告但不禁止，遗留代码的优化策略'},
{'url': 'https://www.kingname.info/2023/11/11/gpts/',
 'anchor': '老板让我加班怎么办？GPTs创建机器人实战'},
{'url': 'https://www.kingname.info/2023/11/11/python-run-other-code/',
 'anchor': '一日一技：如何安全运行别人上传的Python代码？'},
{'url': 'https://www.kingname.info/2023/10/28/parse-json-object/',
 'anchor': '一日一技：爬虫如何解析JavaScript Object？'},
{'url': 'https://www.kingname.info/2023/10/28/json-in-html/',
 'anchor': '一日一技：HTML里面提取的JSON怎么解析不了？'},
{'url': 'https://www.kingname.info/2023/10/17/curl-cffi/',
 'anchor': '一日一技：Requests被网站识别怎么办？'},
{'url': 'https://www.kingname.info/2023/10/17/rubbish/',
 'anchor': '拒绝成为这样的程序员'},
{'url': 'https://www.kingname.info/2023/09/22/json-to-obj/',
 'anchor': '一日一技：JSON如何快速转成对象？'},
{'url': 'https://www.kingname.info/archives/page/2/', 'anchor': '2'},
{'url': 'https://www.kingname.info/archives/page/23/', 'anchor': '23'},
{'url': 'https://hexo.io/', 'anchor': 'Hexo'},
{'url': 'https://theme-next.js.org/muse/', 'anchor': 'NexT.Muse'}]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 with open('/Users/kingname/Downloads/okx.html') as f:
    html = f.read()

import requests
import time

body = {
    'html': html,
    'url': 'https://www.okx.com/learn/curve-finance-guide',
    'fetch_time': int(time.time()),
    'charset': 'utf-8'}
resp = requests.post('https://crawler.kingname.info/gne/crawl_html',
                     json=body,
                     headers={'token': '<TOKEN>'})
print(resp.json())

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

{'title': 'Exploring Curve Finance: A comprehensive guide',
'publish_time_ts': 1686801600,
'publish_time': '2023-06-15 04:00:00',
'content': 'Ethereum’s network is the home to a wide range of unique projects. Ever since it created the ERC-20 token model, thousands of tokens have been launched. In time, new products have emerged as well, such as dApps, decentralized finance (DeFi) protocols and decentralized exchanges (DEXes). One example of a DEX is Curve Finance, which is Ethereum’s go-to DEX for stablecoin trading. It may not be the largest DEX in Ethereum’s ecosystem, but Curve has certainly left a mark. This guide will explore Curve and explain what it is, how it works and what it has to offer. We will also address the project’s token, CRV, and potential risks of the project. What is Curve Finance? Curve Finance is a decentralized exchange that runs on Ethereum’s network. It specifically functions as a decentralized liquidity pool for stablecoin trading. Unlike other exchanges, it does not use an order book. Instead, it relies on an Automated Market Maker (AMM) model for matching liquidity. Curve was founded by Michael Egorov, who previously co-founded the crypto infrastructure protocol NuCypher, where he also served as CTO. He also founded LoanCoin — a decentralized loans networ. Before getting into crypto, he studied at the Moscow Institute of Physics and Technology and the Swinburne University of Technology. Curve Finance is very easy to use. All that you need is an Ethereum wallet. Once you have this, you can start swapping different stablecoins at very low trading fees. While Uniswap is Ethereum’s biggest DEX, Curve Finance is still the biggest for stablecoins. What is an AMM? An Automated Market Maker (AMM) is a DEX protocol used for matching liquidity. It’s used by Curve Finance, as well as many other DEXes. Its role is to replace an order book and use a pricing algorithm to price assets. That way, digital assets can be traded using liquidity pools, instead of matching buyers and sellers. How does Curve Finance work? Curve is a fully decentralized and permissionless protocol, run by the Curve DAO. Curve DAO token CRV is used as its native cryptocurrency. Thanks to its decentralized nature, anyone can provide liquidity to one or more pools. Smart contracts are utilized to carry out any swap. Smart contracts contain liquidity granted to the DEX by its community. In return, community members receive rewards for offering their tokens. Meanwhile, the tokens are used to match orders submitted to the exchange. By adopting this method, Curve users are able to swap two or more tokens. These swaps can include paired stablecoins or wrapped tokens with the underlying collateral. Stable liquidity pools Curve Finance was launched in 2020 when the decentralized finance sector initially blew up. It emerged with the intention of creating an AMM exchange with low fees and efficient fiat savings accounts. The DEX focuses on stablecoins, which allows investors to avoid some of the more volatile aspects of the crypto industry. Meanwhile, it still allows investors to earn high-interest rates by using lending protocols. Incentives for liquidity providers Since Curve Finance’s model cannot function without liquidity providers, attracting as many as possible is imperative. This is why Curve offers various incentives to its users. For example, Curve Finance offers lower transaction fees in comparison to its competitors such as Uniswap. They also allow users to earn rewards from outside of Curve. This is possible thanks to so-called interoperable tokens. For example, if DAI is lent out on Compound Finance. DAI tokens are then exchanged for cDAI. Curve users can use cDAI in Curve’s own liquidity pools. Curve is also integrated with other projects, such as Yearsn and Synthetix. This allows liquidity providers to maximize their return on investment, which in turn, encourages users to return to the platform and provide liquidity to Curve. But that’s is not all, as there are more ways to profit from providing liquidity on this platform. These include: Trading fees: Liquidity providers earn profits from fees paid by the platform’s traders; High APY: Annual Percentage Yields (APY) for stablecoin deposits on Curve can go quite high; Yield Farming : Any funds deposited into LPs that end up not being utilized are used in other DeFi protocols for extra income; veCRV token: By locking up Curve’s native CRV token, users receive veCRV. After that, veCRV holders can use the tokens to boost their deposit APY even further; Boosted pools: Some Curve Finance pools offer further incentives for additional liquidity. This may include high yields for LPs, and Curve is known for yield farming of stablecoins. With this at their disposal, Curve liquidity providers can mix and match these income streams how they see fit. It’s in their interest to earn as much as possible in exchange for the use of their tokens. Curve Finance (CRV) token Back in August 2020, Curve Finance began seeking full decentralization through decentralized governance. In order to achieve this, they launched a Decentralized Autonomous Organization, or DAO, for short. Like other DAOs, Curve Finance introduced their native token, CRV. Following the launch of CRV, Curve released a distribution schedule that is expected to be completed by 2026. The total supply of 3.03b is distributed as such: 62% to community liquidity providers 30% to shareholders (team and investors) with 2-4 years vesting 3% to employees with 2 years vesting Curve DAO token, CRV, grants its holders with voting rights, allowing them to vote on various proposals. They can also make proposals themselves, and let the rest of the community vote on it. Anyone with CRV tokens that are vote-locked can propose updates to the protocol. This can include changing the fees, creating new LPs, adjusting rewards for yield farming and more. The CRV token can be purchased or earned from yield farming after the user deposits assets into LPs. As of April 2023, the token has a circulating supply of 807.69 million and its total supply is 1.9 billion. CRV’s trading volume sits at around $50 million and its max supply is capped at 3.3 million. CRV has quite a few use cases within the Curve Finance ecosystem. Apart from being used as a governance token, it also offers LP rewards and boosts yields. On top of that, it is also used for token burns. Burns are generally used to reduce the circulating supply. They are performed by locking up tokens into a separate, one-way smart contract. The risks of Curve Finance While Curve Finance definitely has plenty of advantages, it is also worth addressing its risks. Fortunately, there are not many of them. The project has been audited by Trail of Bits twice and once by Quantstamp. Of course, this doesn’t mean that the project is risk-free, but it’s a good start. One of the biggest risks that Curve faces is its reliance on other DEFI protocols. As the majority of Curve’s liquidity pools are also supplied by other protocols, to generate additional income. If one of those protocols were to face financial difficulties, there could be a chain reaction that would affect many of them. Does Curve Finance have a future? Curve Finance is one of the most popular AMMs on Ethereum. It facilitates high-volume trades of stablecoins and wrapped cryptocurrencies. It offers tight spreads and low slippage, and numerous DeFi protocols rely heavily on it. As such, it is at the core of Ethereum’s DeFi sector. All of this highly suggests that the project does have a future. There are still risks involved with it, as there are with every crypto project. However, Curve Finance’s chances of remaining popular and operational are still quite good. FAQs What is Curve in crypto? Curve is a decentralized exchange and an AMM protocol that facilitates stablecoin swaps. It also supports swaps of wrapped cryptos. On top of that, it is integrated with a number of other projects in Ethereum’s DeFi sector. How safe is Curve Finance? Curve Finance is as safe as any established cryptocurrency. When dealing with crypto, there are always risks involved. However, the protocol has been audited and is deemed to be a safe platform to use. Who founded Curve Finance? Curve was founded by Michael Egorov. Before founding it, Egorov worked on several other projects in the crypto industry. Is Curve fee free? Curve does not offer zero fees. However, its fees are still quite low in comparison to other similar projects. Is Curve a real bank? Curve Finance is not a bank, but rather a DEX that offers yield farming. Its primary role is to offer stablecoin and wrapped crypto swaps. However, by becoming a liquidity pool provider, you can earn passive income from your dealings with the project.',
'clean_content': '<div><p>Ethereum’s network is the home to a wide range of unique projects. Ever since it created the ERC-20 token model, thousands of tokens have been launched. In time, new products have emerged as well, such as dApps, decentralized finance (DeFi) protocols and decentralized exchanges (DEXes). </p><p>One example of a DEX is Curve Finance, which is Ethereum’s go-to DEX for stablecoin trading. It may not be the largest DEX in Ethereum’s ecosystem, but Curve has certainly left a mark. This guide will explore Curve and explain what it is, how it works and what it has to offer. We will also address the project’s token, CRV, and potential risks of the project.</p><h2>What is Curve Finance?</h2><p>Curve Finance is a decentralized exchange that runs on Ethereum’s network. It specifically functions as a decentralized liquidity pool for stablecoin trading. Unlike other exchanges, it does not use an order book. Instead, it relies on an Automated Market Maker (AMM) model for matching liquidity. </p><p>Curve was founded by Michael Egorov, who previously co-founded the crypto infrastructure protocol NuCypher, where he also served as CTO. He also founded LoanCoin — a decentralized loans networ. Before getting into crypto, he studied at the Moscow Institute of Physics and Technology and the Swinburne University of Technology.</p><p>Curve Finance is very easy to use. All that you need is an Ethereum wallet. Once you have this, you can start swapping different stablecoins at very low trading fees. While Uniswap is Ethereum’s biggest DEX, Curve Finance is still the biggest for stablecoins.</p><h2>What is an AMM?</h2><p>An Automated Market Maker (AMM) is a DEX protocol used for matching liquidity. It’s used by Curve Finance, as well as many other DEXes. Its role is to replace an order book and use a pricing algorithm to price assets. That way, digital assets can be traded using liquidity pools, instead of matching buyers and sellers. </p><h2>How does Curve Finance work?</h2><p>Curve is a fully decentralized and permissionless protocol, run by the Curve DAO. Curve DAO token CRV is used as its native cryptocurrency. Thanks to its decentralized nature, anyone can provide liquidity to one or more pools. Smart contracts are utilized to carry out any swap.</p><p>Smart contracts contain liquidity granted to the DEX by its community. In return, community members receive rewards for offering their tokens. Meanwhile, the tokens are used to match orders submitted to the exchange. By adopting this method, Curve users are able to swap two or more tokens. These swaps can include paired stablecoins or wrapped tokens with the underlying collateral. </p><h2>Stable liquidity pools</h2><p>Curve Finance was launched in 2020 when the decentralized finance sector initially blew up. It emerged with the intention of creating an AMM exchange with low fees and efficient fiat savings accounts. The DEX focuses on stablecoins, which allows investors to avoid some of the more volatile aspects of the crypto industry. Meanwhile, it still allows investors to earn high-interest rates by using lending protocols. </p><h2>Incentives for liquidity providers</h2><p>Since Curve Finance’s model cannot function without liquidity providers, attracting as many as possible is imperative. This is why Curve offers various incentives to its users. For example, Curve Finance offers lower transaction fees in comparison to its competitors such as Uniswap. They also allow users to earn rewards from outside of Curve. This is possible thanks to so-called interoperable tokens. For example, if DAI is lent out on Compound Finance. DAI tokens are then exchanged for cDAI. Curve users can use cDAI in Curve’s own liquidity pools. </p><p>Curve is also integrated with other projects, such as Yearsn and Synthetix. This allows liquidity providers to maximize their return on investment, which in turn, encourages users to return to the platform and provide liquidity to Curve. </p><p>But that’s is not all, as there are more ways to profit from providing liquidity on this platform. These include:</p><ul><li>Trading fees: Liquidity providers earn profits from fees paid by the platform’s traders;</li><li>High APY: Annual Percentage Yields (APY) for stablecoin deposits on Curve can go quite high;</li><li>Yield Farming : Any funds deposited into LPs that end up not being utilized are used in other DeFi protocols for extra income; </li><li>veCRV token: By locking up Curve’s native CRV token, users receive veCRV. After that, veCRV holders can use the tokens to boost their deposit APY even further;</li><li>Boosted pools: Some Curve Finance pools offer further incentives for additional liquidity. This may include high yields for LPs, and Curve is known for yield farming of stablecoins.</li></ul><p>With this at their disposal, Curve liquidity providers can mix and match these income streams how they see fit. It’s in their interest to earn as much as possible in exchange for the use of their tokens.</p><h2>Curve Finance (CRV) token</h2><p>Back in August 2020, Curve Finance began seeking full decentralization through decentralized governance. In order to achieve this, they launched a Decentralized Autonomous Organization, or DAO, for short. Like other DAOs, Curve Finance introduced their native token, CRV.</p><p>Following the launch of CRV, Curve released a distribution schedule that is expected to be completed by 2026. </p><figure><img src="https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/77FafUZE1sjddle2cvbVwT/a02397f818dac7686303ee8da38afad0/Crv.jpg" /></figure><p>The total supply of 3.03b is distributed as such:</p><ul><li>62% to community liquidity providers</li><li>30% to shareholders (team and investors) with 2-4 years vesting</li><li>3% to employees with 2 years vesting</li></ul><p>Curve DAO token, CRV, grants its holders with voting rights, allowing them to vote on various proposals. They can also make proposals themselves, and let the rest of the community vote on it. Anyone with CRV tokens that are vote-locked can propose updates to the protocol. This can include changing the fees, creating new LPs, adjusting rewards for yield farming and more.</p><p>The CRV token can be purchased or earned from yield farming after the user deposits assets into LPs. </p><figure><img src="https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/lWtnJYgt2NuvZ0c841C4k/07de91ea5e7a530dbc006f97dc5a213b/Curve.jpg" /></figure><p>As of April 2023, the token has a circulating supply of 807.69 million and its total supply is 1.9 billion. CRV’s trading volume sits at around $50 million and its max supply is capped at 3.3 million.</p><p>CRV has quite a few use cases within the Curve Finance ecosystem. Apart from being used as a governance token, it also offers LP rewards and boosts yields. On top of that, it is also used for token burns. Burns are generally used to reduce the circulating supply. They are performed by locking up tokens into a separate, one-way smart contract. </p><h2>The risks of Curve Finance</h2><p>While Curve Finance definitely has plenty of advantages, it is also worth addressing its risks. Fortunately, there are not many of them. The project has been audited by Trail of Bits twice and once by Quantstamp. Of course, this doesn’t mean that the project is risk-free, but it’s a good start. </p><p>One of the biggest risks that Curve faces is its reliance on other DEFI protocols. As the majority of Curve’s liquidity pools are also supplied by other protocols, to generate additional income. If one of those protocols were to face financial difficulties, there could be a chain reaction that would affect many of them.</p><h2>Does Curve Finance have a future?</h2><p>Curve Finance is one of the most popular AMMs on Ethereum. It facilitates high-volume trades of stablecoins and wrapped cryptocurrencies. It offers tight spreads and low slippage, and numerous DeFi protocols rely heavily on it. As such, it is at the core of Ethereum’s DeFi sector.</p><p>All of this highly suggests that the project does have a future. There are still risks involved with it, as there are with every crypto project. However, Curve Finance’s chances of remaining popular and operational are still quite good.</p><h2>FAQs</h2><h2>What is Curve in crypto?</h2><p>Curve is a decentralized exchange and an AMM protocol that facilitates stablecoin swaps. It also supports swaps of wrapped cryptos. On top of that, it is integrated with a number of other projects in Ethereum’s DeFi sector.</p><h2>How safe is Curve Finance?</h2><p>Curve Finance is as safe as any established cryptocurrency. When dealing with crypto, there are always risks involved. However, the protocol has been audited and is deemed to be a safe platform to use.</p><h2>Who founded Curve Finance?</h2><p>Curve was founded by Michael Egorov. Before founding it, Egorov worked on several other projects in the crypto industry. </p><h2>Is Curve fee free?</h2><p>Curve does not offer zero fees. However, its fees are still quite low in comparison to other similar projects.</p><h2>Is Curve a real bank?</h2><p>Curve Finance is not a bank, but rather a DEX that offers yield farming. Its primary role is to offer stablecoin and wrapped crypto swaps. However, by becoming a liquidity pool provider, you can earn passive income from your dealings with the project.</p></div>',
'content_list': [{'type': 'text',
  'data': 'Ethereum’s network is the home to a wide range of unique projects. Ever since it created the ERC-20 token model, thousands of tokens have been launched. In time, new products have emerged as well, such as dApps, decentralized finance (DeFi) protocols and decentralized exchanges (DEXes).',
  'caption': ''},
 {'type': 'text',
  'data': 'One example of a DEX is Curve Finance, which is Ethereum’s go-to DEX for stablecoin trading. It may not be the largest DEX in Ethereum’s ecosystem, but Curve has certainly left a mark. This guide will explore Curve and explain what it is, how it works and what it has to offer. We will also address the project’s token, CRV, and potential risks of the project.',
  'caption': ''},
 {'type': 'text', 'data': 'What is Curve Finance?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance is a decentralized exchange that runs on Ethereum’s network. It specifically functions as a decentralized liquidity pool for stablecoin trading. Unlike other exchanges, it does not use an order book. Instead, it relies on an Automated Market Maker (AMM) model for matching liquidity.',
  'caption': ''},
 {'type': 'text',
  'data': 'Curve was founded by Michael Egorov, who previously co-founded the crypto infrastructure protocol NuCypher, where he also served as CTO. He also founded LoanCoin — a decentralized loans networ. Before getting into crypto, he studied at the Moscow Institute of Physics and Technology and the Swinburne University of Technology.',
  'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance is very easy to use. All that you need is an Ethereum wallet. Once you have this, you can start swapping different stablecoins at very low trading fees. While Uniswap is Ethereum’s biggest DEX, Curve Finance is still the biggest for stablecoins.',
  'caption': ''},
 {'type': 'text', 'data': 'What is an AMM?', 'caption': ''},
 {'type': 'text',
  'data': 'An Automated Market Maker (AMM) is a DEX protocol used for matching liquidity. It’s used by Curve Finance, as well as many other DEXes. Its role is to replace an order book and use a pricing algorithm to price assets. That way, digital assets can be traded using liquidity pools, instead of matching buyers and sellers.',
  'caption': ''},
 {'type': 'text', 'data': 'How does Curve Finance work?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve is a fully decentralized and permissionless protocol, run by the Curve DAO. Curve DAO token CRV is used as its native cryptocurrency. Thanks to its decentralized nature, anyone can provide liquidity to one or more pools. Smart contracts are utilized to carry out any swap.',
  'caption': ''},
 {'type': 'text',
  'data': 'Smart contracts contain liquidity granted to the DEX by its community. In return, community members receive rewards for offering their tokens. Meanwhile, the tokens are used to match orders submitted to the exchange. By adopting this method, Curve users are able to swap two or more tokens. These swaps can include paired stablecoins or wrapped tokens with the underlying collateral.',
  'caption': ''},
 {'type': 'text', 'data': 'Stable liquidity pools', 'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance was launched in 2020 when the decentralized finance sector initially blew up. It emerged with the intention of creating an AMM exchange with low fees and efficient fiat savings accounts. The DEX focuses on stablecoins, which allows investors to avoid some of the more volatile aspects of the crypto industry. Meanwhile, it still allows investors to earn high-interest rates by using lending protocols.',
  'caption': ''},
 {'type': 'text',
  'data': 'Incentives for liquidity providers',
  'caption': ''},
 {'type': 'text',
  'data': 'Since Curve Finance’s model cannot function without liquidity providers, attracting as many as possible is imperative. This is why Curve offers various incentives to its users. For example, Curve Finance offers lower transaction fees in comparison to its competitors such as Uniswap. They also allow users to earn rewards from outside of Curve. This is possible thanks to so-called interoperable tokens. For example, if DAI is lent out on Compound Finance. DAI tokens are then exchanged for cDAI. Curve users can use cDAI in Curve’s own liquidity pools.',
  'caption': ''},
 {'type': 'text',
  'data': 'Curve is also integrated with other projects, such as Yearsn and Synthetix. This allows liquidity providers to maximize their return on investment, which in turn, encourages users to return to the platform and provide liquidity to Curve.',
  'caption': ''},
 {'type': 'text',
  'data': 'But that’s is not all, as there are more ways to profit from providing liquidity on this platform. These include:',
  'caption': ''},
 {'type': 'text',
  'data': 'Trading fees: Liquidity providers earn profits from fees paid by the platform’s traders;',
  'caption': ''},
 {'type': 'text',
  'data': 'High APY: Annual Percentage Yields (APY) for stablecoin deposits on Curve can go quite high;',
  'caption': ''},
 {'type': 'text',
  'data': 'Yield Farming : Any funds deposited into LPs that end up not being utilized are used in other DeFi protocols for extra income;',
  'caption': ''},
 {'type': 'text',
  'data': 'veCRV token: By locking up Curve’s native CRV token, users receive veCRV. After that, veCRV holders can use the tokens to boost their deposit APY even further;',
  'caption': ''},
 {'type': 'text',
  'data': 'Boosted pools: Some Curve Finance pools offer further incentives for additional liquidity. This may include high yields for LPs, and Curve is known for yield farming of stablecoins.',
  'caption': ''},
 {'type': 'text',
  'data': 'With this at their disposal, Curve liquidity providers can mix and match these income streams how they see fit. It’s in their interest to earn as much as possible in exchange for the use of their tokens.',
  'caption': ''},
 {'type': 'text', 'data': 'Curve Finance (CRV) token', 'caption': ''},
 {'type': 'text',
  'data': 'Back in August 2020, Curve Finance began seeking full decentralization through decentralized governance. In order to achieve this, they launched a Decentralized Autonomous Organization, or DAO, for short. Like other DAOs, Curve Finance introduced their native token, CRV.',
  'caption': ''},
 {'type': 'text',
  'data': 'Following the launch of CRV, Curve released a distribution schedule that is expected to be completed by 2026.',
  'caption': ''},
 {'type': 'image',
  'data': 'https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/77FafUZE1sjddle2cvbVwT/a02397f818dac7686303ee8da38afad0/Crv.jpg',
  'caption': ''},
 {'type': 'text',
  'data': 'The total supply of 3.03b is distributed as such:',
  'caption': ''},
 {'type': 'text',
  'data': '62% to community liquidity providers',
  'caption': ''},
 {'type': 'text',
  'data': '30% to shareholders (team and investors) with 2-4 years vesting',
  'caption': ''},
 {'type': 'text',
  'data': '3% to employees with 2 years vesting',
  'caption': ''},
 {'type': 'text',
  'data': 'Curve DAO token, CRV, grants its holders with voting rights, allowing them to vote on various proposals. They can also make proposals themselves, and let the rest of the community vote on it. Anyone with CRV tokens that are vote-locked can propose updates to the protocol. This can include changing the fees, creating new LPs, adjusting rewards for yield farming and more.',
  'caption': ''},
 {'type': 'text',
  'data': 'The CRV token can be purchased or earned from yield farming after the user deposits assets into LPs.',
  'caption': ''},
 {'type': 'image',
  'data': 'https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/lWtnJYgt2NuvZ0c841C4k/07de91ea5e7a530dbc006f97dc5a213b/Curve.jpg',
  'caption': ''},
 {'type': 'text',
  'data': 'As of April 2023, the token has a circulating supply of 807.69 million and its total supply is 1.9 billion. CRV’s trading volume sits at around $50 million and its max supply is capped at 3.3 million.',
  'caption': ''},
 {'type': 'text',
  'data': 'CRV has quite a few use cases within the Curve Finance ecosystem. Apart from being used as a governance token, it also offers LP rewards and boosts yields. On top of that, it is also used for token burns. Burns are generally used to reduce the circulating supply. They are performed by locking up tokens into a separate, one-way smart contract.',
  'caption': ''},
 {'type': 'text', 'data': 'The risks of Curve Finance', 'caption': ''},
 {'type': 'text',
  'data': 'While Curve Finance definitely has plenty of advantages, it is also worth addressing its risks. Fortunately, there are not many of them. The project has been audited by Trail of Bits twice and once by Quantstamp. Of course, this doesn’t mean that the project is risk-free, but it’s a good start.',
  'caption': ''},
 {'type': 'text',
  'data': 'One of the biggest risks that Curve faces is its reliance on other DEFI protocols. As the majority of Curve’s liquidity pools are also supplied by other protocols, to generate additional income. If one of those protocols were to face financial difficulties, there could be a chain reaction that would affect many of them.',
  'caption': ''},
 {'type': 'text', 'data': 'Does Curve Finance have a future?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance is one of the most popular AMMs on Ethereum. It facilitates high-volume trades of stablecoins and wrapped cryptocurrencies. It offers tight spreads and low slippage, and numerous DeFi protocols rely heavily on it. As such, it is at the core of Ethereum’s DeFi sector.',
  'caption': ''},
 {'type': 'text',
  'data': 'All of this highly suggests that the project does have a future. There are still risks involved with it, as there are with every crypto project. However, Curve Finance’s chances of remaining popular and operational are still quite good.',
  'caption': ''},
 {'type': 'text', 'data': 'FAQs', 'caption': ''},
 {'type': 'text', 'data': 'What is Curve in crypto?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve is a decentralized exchange and an AMM protocol that facilitates stablecoin swaps. It also supports swaps of wrapped cryptos. On top of that, it is integrated with a number of other projects in Ethereum’s DeFi sector.',
  'caption': ''},
 {'type': 'text', 'data': 'How safe is Curve Finance?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance is as safe as any established cryptocurrency. When dealing with crypto, there are always risks involved. However, the protocol has been audited and is deemed to be a safe platform to use.',
  'caption': ''},
 {'type': 'text', 'data': 'Who founded Curve Finance?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve was founded by Michael Egorov. Before founding it, Egorov worked on several other projects in the crypto industry.',
  'caption': ''},
 {'type': 'text', 'data': 'Is Curve fee free?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve does not offer zero fees. However, its fees are still quite low in comparison to other similar projects.',
  'caption': ''},
 {'type': 'text', 'data': 'Is Curve a real bank?', 'caption': ''},
 {'type': 'text',
  'data': 'Curve Finance is not a bank, but rather a DEX that offers yield farming. Its primary role is to offer stablecoin and wrapped crypto swaps. However, by becoming a liquidity pool provider, you can earn passive income from your dealings with the project.',
  'caption': ''}],
'summary': 'Ethereum’s network is the home to a wide range of unique projects. Ever since it created the ERC-20 token model, thousands of tokens have been launched. In time, new products have emerged as well, such as dApps, decentralized finance (DeFi) protocols and decentralized exchanges (DEXes). One example of a...',
'canonical_url': 'https://www.okx.com/learn/curve-finance-guide',
'image_count': 2,
'image_urls': ['https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/77FafUZE1sjddle2cvbVwT/a02397f818dac7686303ee8da38afad0/Crv.jpg',
 'https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/lWtnJYgt2NuvZ0c841C4k/07de91ea5e7a530dbc006f97dc5a213b/Curve.jpg'],
'image_captions': ['', ''],
'head_meta': {'og:type': 'article',
 'description': 'Ethereum’s network is the home',
 'og:description': '',
 'twitter:image': 'https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/56aHhyers8WrWwWSE6M0x3/5c15ce05044a4cfa63f86453cbf86e35/MP_Cover.png',
 'viewport': 'width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no',
 'Author': 'OKX',
 'og:site_name': 'OKX',
 'keywords': 'BTC, BTC trading platform, ETH, EOS, Qtum, NEO, Ripple, BTC price, LTC, BCH, ETC, Blockchain',
 'og:image': 'https://static.okx.com/cdn/assets/plugins/contentful/4nqoo8goeymu/56aHhyers8WrWwWSE6M0x3/5c15ce05044a4cfa63f86453cbf86e35/MP_Cover.png',
 'browsermode': 'application',
 'og:locale': 'en_US',
 'twitter:site': '@okx',
 'og:url': 'https://www.okx.com/learn/curve-finance-guide',
 'og:title': 'Exploring Curve Finance: A comprehensive guide',
 'x5-orientation': 'portrait',
 'x5-page-mode': 'app',
 'google-site-verification': 'SVJL-WGbe8_1J05O3I8V4ehAs8L89UDA-bcAyAJ2SLw',
 'full-screen': 'yes',
 'twitter:title': 'Exploring Curve Finance: A comprehensive guide',
 'twitter:card': 'summary_large_image',
 'apple-mobile-web-app-capable': 'yes',
 'x5-fullscreen': 'true',
 'Copyright': 'okx.com',
 'twitter:description': 'Ethereum’s network is the home'},
'author': ['OKX'],
'timezone': '',
'url': 'https://www.okx.com/learn/curve-finance-guide',
'amp_url': '',
'breadcrumb': [{'level': 0,
  'text': 'Learn',
  'link': 'https://www.okx.com/learn'},
 {'level': 1,
  'text': 'Glossary',
  'link': 'https://www.okx.com/learn/category/blockchain-glossary'},
 {'level': 2, 'text': 'Article', 'link': ''}]}

1
2
3
4
5
6
7
8
9
10
11
12

 <!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h1>我是假标题</h1>
        {你的HTML片段}
    </body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from typing import TypedDict  
  
  
class User(TypedDict):  
    name: str  
    age: int  
    address: str  
    salary: int  
  
  
kingname: User = {  
    'name': '青南',  
    'age': 18,  
    'address': '上海',  
    'salary': 9999999999  
}  
  
  
def test_dict(user: User):  
    print(user['name'])