# python 3.12.1 Date：2023年12月8日
是最新的维护版本，包含自 3.12.0 以来的 400 多个错误修复、构建改进和文档[更改](https://docs.python.org/3.12/contents.html)。

## 1. typing的优化：
```shell
from typing import Iterable, TypeVar
T = TypeVar('T')

def max[T](args: Iterable[T]) -> T:
    ...
class list[T]:
    def __getitem__(self, index: int, /) -> T:
        ...

    def append(self, item: T) -> None:
       ...
# py_3.10是用显示声明类型别名。Point: TypeAlias = tuple[float, float]
# py_3.9以及下的版本，是用直接赋值定义类型别名，Point = Tuple[float, float]
type Point = tuple[float, float]
# type 语句专门用于声明类型别名，让代码里类型定义的意图更加清晰明确。
type Point[T] = tuple[T, T]

```
### TypeVarTuple 和ParamSpec
```shell
type IntFunc[**P] = Callable[P, int]  # ParamSpec
type LabeledTuple[*Ts] = tuple[str, *Ts]  # TypeVarTuple
type HashableSequence[T: Hashable] = Sequence[T]  # TypeVar with bound
type IntOrStrSequence[T: (int, str)] = Sequence[T]  # TypeVar with constraints
```
以下将结合 Python 的类型注解和类型变量相关知识，对你给出的四个类型别名定义进行详细解释。这些定义主要使用了 Python 的类型系统新特性，如 `ParamSpec`、`TypeVarTuple`、`TypeVar` 等，并且这些特性大多从 Python 3.10 及以上版本开始引入，部分更高级特性如 `TypeVarTuple` 需 Python 3.11 及以上版本支持。

#### 1. `type IntFunc[**P] = Callable[P, int]  # ParamSpec`
```python
from typing import Callable, ParamSpec

P = ParamSpec('P')
type IntFunc[**P] = Callable[P, int]

# 示例函数
def add(a: int, b: int) -> int:
    return a + b

# 使用类型别名注解
func: IntFunc[[int, int]] = add
```
- **含义**：此类型别名 `IntFunc` 借助 `ParamSpec`（`P`）来表示一个可调用对象（函数），该对象可以接受任意数量和类型的参数（`P` 代表参数规范），但返回值类型必须是 `int`。
- **用途**：当你需要定义一系列函数，它们的返回值都是整数，不过参数类型和数量不确定时，就可以使用这个类型别名进行类型注解。

#### 2. `type LabeledTuple[*Ts] = tuple[str, *Ts]  # TypeVarTuple`
```python
from typing import TypeVarTuple

Ts = TypeVarTuple('Ts')
type LabeledTuple[*Ts] = tuple[str, *Ts]

# 示例元组
labeled_int_tuple: LabeledTuple[int] = ('label', 1)
labeled_int_str_tuple: LabeledTuple[int, str] = ('label', 1, 'value')
```
- **含义**：`LabeledTuple` 是一个泛型类型别名，利用 `TypeVarTuple`（`Ts`）表示它可以包含任意数量和类型的元素。这个元组的第一个元素类型固定为 `str`，后续元素的类型由 `Ts` 决定。
- **用途**：当你需要创建带有标签的元组，且标签之后的元素数量和类型不固定时，可使用此类型别名。

#### 3. `type HashableSequence[T: Hashable] = Sequence[T]  # TypeVar with bound`
```python
from collections.abc import Sequence
from typing import TypeVar
from collections.abc import Hashable

T = TypeVar('T', bound=Hashable)
type HashableSequence[T: Hashable] = Sequence[T]

# 示例序列
hashable_list: HashableSequence[int] = [1, 2, 3]
```
- **含义**：`HashableSequence` 是一个泛型类型别名，`TypeVar`（`T`）被约束为 `Hashable` 类型，意味着 `T` 必须是可哈希的类型。该类型别名表示一个序列，序列中的元素类型为可哈希的 `T`。
- **用途**：当你需要处理包含可哈希元素的序列时，可使用此类型别名，确保序列中的元素都能用于需要可哈希对象的场景，如作为字典的键。

#### 4. `type IntOrStrSequence[T: (int, str)] = Sequence[T]`
```python
from collections.abc import Sequence
from typing import TypeVar

T = TypeVar('T', int, str)
type IntOrStrSequence[T: (int, str)] = Sequence[T]

# 示例序列
int_sequence: IntOrStrSequence[int] = [1, 2, 3]
str_sequence: IntOrStrSequence[str] = ['a', 'b', 'c']
```
- **含义**：`IntOrStrSequence` 是一个泛型类型别名，`TypeVar`（`T`）被限制为只能是 `int` 或者 `str` 类型。该类型别名表示一个序列，序列中的元素类型只能是整数或者字符串。
- **用途**：当你需要处理只包含整数或字符串元素的序列时，可使用此类型别名，增强代码的类型安全性和可读性。

这些类型别名定义借助 Python 的类型系统，能够让代码的类型注解更加灵活和精确，提高代码的可读性和可维护性。 

## 2. 更灵活的f字符串解析
主要新功能：
- [更灵活的 f 字符串解析](https://docs.python.org/3.12/whatsnew/3.12.html#pep-701-syntactic-formalization-of-f-strings)，允许许多以前不允许的事情 （PEP 701）。
    
    - 引号重用：
    ```python
    >>> songs = ['Take me back to Eden', 'Alkaline', 'Ascensionism']
    >>> f"This is the playlist: {", ".join(songs)}"
    'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
    ```
    - 无限制的嵌套
    ```python
    >>> f"""{f'''{f'{f"{1+1}"}'}'''}"""
    '2'
    ```
    - 多行表达式和注释：
    ```python
    >>> f"This is the playlist: {", ".join([
    ...     'Take me back to Eden',  # My, my, those eyes like fire
    ...     'Alkaline',              # Not acid nor alkaline
    ...     'Ascensionism'           # Take to the broken skies at last
    ... ])}"
    'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
    ```
    - 反斜杠和unicode字符：
    ```python
    >>> print(f"This is the playlist: {"\n".join(songs)}")
    This is the playlist: Take me back to Eden
    Alkaline
    Ascensionism
    >>> print(f"This is the playlist: {"\N{BLACK HEART SUIT}".join(songs)}")
    This is the playlist: Take me back to Eden♥Alkaline♥Ascensionism
    ```
    - 错误更加准确
    
        但错误消息不包括错误在行中的确切位置，并且还人为地将表达式括在括号中。在 Python 3.12 中，由于使用 PEG 解析器解析 f 字符串，因此错误消息可以更精确并显示整行：
    ```python
    >>> my_string = f"{x z y}" + f"{1 + 1}"
      File "<stdin>", line 1
      my_string = f"{x z y}" + f"{1 + 1}"
                   ^^^
    SyntaxError: invalid syntax. Perhaps you forgot a comma?
    ```
## 3. 支持python代码中的缓冲区协议
- 支持 Python 代码中的缓冲区协议 （[PEP 688](https://peps.python.org/pep-0688/)）

## 4. 每个解释器GIL
PEP 684 引入了按解释者指定的 GIL，因此现在可以为每个解释者创建具有唯一 GIL 的子解释器。这允许 Python 程序充分利用多个 CPU 内核。目前只能通过 C-API 使用，但预计 3.13 中将提供 Python API。

从结果来看：多解释器的运行时间，提高了60倍，期待3.13的提升。可以考虑在CPU的密集型任务当中，加入此功能（改成一个装饰器）

```python
import time
import multiprocessing
import ctypes

# 加载 Python 动态链接库
python_lib = ctypes.CDLL(None)

# 定义 PyInterpreterConfig 结构体
class PyInterpreterConfig(ctypes.Structure):
    _fields_ = [
        ("check_multi_interp_extensions", ctypes.c_int),
        ("gil", ctypes.c_int)
    ]

# 定义常量
PyInterpreterConfig_OWN_GIL = 1

# 定义函数原型
python_lib.Py_NewInterpreterFromConfig.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(PyInterpreterConfig)]
python_lib.Py_NewInterpreterFromConfig.restype = ctypes.c_int

python_lib.PyStatus_Exception.argtypes = [ctypes.c_int]
python_lib.PyStatus_Exception.restype = ctypes.c_int

# 模拟 CPU 密集型任务
def cpu_intensive_task():
    start_time = time.time()
    while time.time() - start_time < 5:
        _ = 1 + 1

# 单解释器运行任务
def single_interpreter():
    cpu_intensive_task()

# 多解释器运行任务
def multi_interpreter():
    config = PyInterpreterConfig()
    config.check_multi_interp_extensions = 1
    config.gil = PyInterpreterConfig_OWN_GIL

    tstate = ctypes.c_void_p()
    status = python_lib.Py_NewInterpreterFromConfig(ctypes.byref(tstate), ctypes.byref(config))
    if python_lib.PyStatus_Exception(status):
        return -1
    cpu_intensive_task()

if __name__ == "__main__":
    num_cores = multiprocessing.cpu_count()

    # 单解释器测试
    single_start_time = time.time()
    processes = [multiprocessing.Process(target=single_interpreter) for _ in range(num_cores)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    single_end_time = time.time()
    single_total_time = single_end_time - single_start_time

    # 多解释器测试
    multi_start_time = time.time()
    processes = [multiprocessing.Process(target=multi_interpreter) for _ in range(num_cores)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    multi_end_time = time.time()
    multi_total_time = multi_end_time - multi_start_time

    print(f"单解释器总时间: {single_total_time} 秒")
    print(f"多解释器总时间: {multi_total_time} 秒")
    if multi_total_time < single_total_time:
        print("多解释器利用多核 CPU 更高效。")
    else:
        print("单解释器和多解释器性能相近或单解释器更优。")


""""
运行结果：
单解释器总时间: 6.34592080116272 秒
多解释器总时间: 0.10944199562072754 秒
多解释器利用多核 CPU 更高效。
"""
```

## 5. 理解式内联

![image.png](/static/img/8b4e481581c95e1aaa28799cc6482cd5.image.webp)

从详细的图片可以看出，之前的版本会在列表推导式、字典推导式，进行创建一个一次性函数对象，用完之后，进行丢弃。

而新的版本是：不需要单独的代码对象，也不再需要创建一次性的函数对象，也不再需要创建和销毁python框架。

**locals包含外部变量**
```python
>>> def f(lst):
...    return [locals() for x in lst]
...
>>> f(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
TypeError: 'int' object is not iterable
>>> f([1])
[{'lst': [1], 'x': 1}]
>>>
```

对比3.11

```python
Python 3.11.10 (main, Oct  3 2024, 02:37:52) [Clang 14.0.6 ] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def f(lst):
... ...    return [locals() for x in lst]
  File "<stdin>", line 2
    ...    return [locals() for x in lst]
    ^
IndentationError: expected an indented block after function definition on line 1
>>> def f(lst):
...    return [locals() for x in lst]
...
>>> f([1])
[{'.0': <list_iterator object at 0x10cb4e0b0>, 'x': 1}]
>>>
```

## 6. 与TypeHint相关的新功能
1.  PEP 692： 使用 TypedDict 进行更精确的 **kwargs 类型
在 PEP 484 引入的函数签名中键入 **kwargs 仅在所有 **kwargs 都属于相同类型的情况下才允许有效注释。

PEP 692 指定了一种更精确的键入 **kwargs 的方法，它依赖于类型化的字典：

```python
from typing import TypedDict, Unpack

class Movie(TypedDict):
  name: str
  year: int

def foo(**kwargs: Unpack[Movie]): ...
```


2. PEP 698： 覆盖静态类型的装饰器¶

增加一种，可以检查覆盖父类方法的，是否有调用。如果去掉override，在badchild中他是没有get_color,她就会调用base的方法。但实际上，你写的代码是为了调用badChild的。

so，这个方法还是对于你要覆盖父类方法有很大的用处
```python
from typing import override

class Base:
  def get_color(self) -> str:
    return "blue"

class GoodChild(Base):
  @override  # ok: overrides Base.get_color
  def get_color(self) -> str:
    return "yellow"

class BadChild(Base):
  @override  # type checker error: does not override Base.get_color
  def get_colour(self) -> str:
    return "red"


good = GoodChild()
bad = BadChild()
print(good.get_color())
print(bad.get_color())

```
## 7. canlendar的使用，增加月和日

[链接地址](https://docs.python.org/3.12/library/calendar.html#calendar.Month)
![image.png](/static/img/1e081f384bcad7d4c6c2a6aa88f52a30.image.webp)
## 8. itertools.batched，批量储量
将列表、字符串，批量分割成你规定的大小

```python
flattened_data = ['roses', 'red', 'violets', 'blue', 'sugar', 'sweet']
unflattened = list(batched(flattened_data, 2))
unflattened
[('roses', 'red'), ('violets', 'blue'), ('sugar', 'sweet')]

# batched('ABCDEFG', 3) → ABC DEF G

h
```
反过来：合并的方法是: `itertools.chain(*iterables)`



## 9. os.path.splitroot(path)

将路径名路径拆分为一个 3 项元组 （drive， root， tail），其中 drive 是设备名称或挂载点，root 是驱动器后面的一串分隔符，tail 是 root 之后的所有内容。这些项中的任何一项都可能是空字符串。在所有情况下，drive + root + tail 都将与 path 相同。

看情况，用起来是有点不准的。哈哈

```python
splitroot('C:/Users/Sam')
('C:', '/', 'Users/Sam')
splitroot('//Server/Share/Users/Sam')
('//Server/Share', '/', 'Users/Sam')
```

## 10. unittest,添加--durations,显示N个最慢的测试用例
```python
python3 -m unittest --durations=3 lib.tests.test_threading
.....
Slowest test durations
----------------------------------------------------------------------
1.210s     test_timeout (Lib.test.test_threading.BarrierTests)
1.003s     test_default_timeout (Lib.test.test_threading.BarrierTests)
0.518s     test_timeout (Lib.test.test_threading.EventTests)

(0.000 durations hidden.  Use -v to show these durations.)
----------------------------------------------------------------------
Ran 158 tests in 9.869s

OK (skipped=3)
```

## 11. uuid增加command-line 功能
```python
# generate a random uuid - by default uuid4() is used
$ python -m uuid

# generate a uuid using uuid1()
$ python -m uuid -u uuid1

# generate a uuid using uuid5
$ python -m uuid -u uuid5 -n @url -N example.com
```

将来有时间再加上3.12之前的PEP，还是挺有意思的👂🏻

📅 python3.12版本

# EverMemOS：企业级智能记忆系统
LLM训练大致分为三个阶段，Pre-Training学知识，SFT学说话，Post-Training学思考。这样的LLM用作问答没有问题，但是用作AI助理或者家庭机器人就有一个非常致命的缺点：LLM没有记忆，每次对话默认从零开始。除非附带历史信息，LLM不会记得你的任何信息，无法提供个性化、连贯的服务。


```
EverMemOS: Enterprise-grade intelligent memory system
LLM training is roughly divided into three stages: Pre-Training to learn knowledge, SFT to learn to speak, and Post-Training to learn. There is no problem with such LLMs being used as question answerers, but they have a very fatal drawback when used as AI assistants or home robots: LLMs have no memory, and each conversation starts from scratch by default. LLMs will not remember any of your information unless accompanied by historical information and cannot provide personalized, coherent services.
```
## LLM记忆的设计模式
主要分为两类：第一类是模拟人类的记忆方式（来自论文CoALA），第二类是从计算机工程的角度设计（Letta提出）。
```
Design patterns for LLM memory
There are two main categories: the first is to simulate the way humans remember (from the paper CoALA), and the second is to design from the perspective of computer engineering (proposed by Letta).
```
拟人化记忆的四种记忆类型：
- 临时记忆：当前对话的内容，对应到LLM就是context，LLM的context的长度通常是256K tokens，Gemini则能达到1M tokens。
- 事实类记忆：这类记忆通常对所有人都是一样的。对于人类来说，就是人学到的知识和事实，例如水在0度结冰、小明不喜欢吃香菜；对于LLM，就是关于用户的信息，例如用户是男性、名字叫Gorden。
- 经历类记忆：这类记忆则因人而异。对于人类来说，就是发生过的事，例如上个周末去了公园、吃了火锅；对于LLM来说，过去的聊天记录提炼出来的总结都可以算作这类记忆，例如用户提问了如何减肥。
- 技能类记忆：对人类来说，就是如何开车这种学会后不必再思考、形成了本能的技能；对于LLM来说，就是system prompt，例如让LLM回复时必须使用Json格式。（例如http://CLAUDE.md）
```
The four types of memory of anthropomorphic memory:
· Temporary memory: The content of the current conversation corresponds to the LLM as the context, the length of the LLM context is usually 256K tokens, and Gemini can reach 1M tokens.
· Factual memory: This type of memory is usually the same for all people. For humans, it is the knowledge and facts that people have learned, such as water freezing at 0 degrees, Xiao Ming doesn't like to eat coriander; For LLMs, it is information about the user, such as whether the user is male and given the name Gorden.
· Experiential memory: This type of memory varies from person to person. For humans, it is what has happened, such as going to the park and eating hot pot last weekend; For LLMs, summaries extracted from past chat records can be counted as such memories, such as when a user asks how to lose weight.
· Skill memory: For humans, it is how to drive, which is a skill that does not have to think and form instincts after learning; For LLMs, it's a system prompt, for example, the LLM must use Json format when replying. (e.g. http:// CLAUDE.md)
```

计算机工程出发的记忆类型：
- 消息缓冲区：即当前对话内容，对应拟人化记忆的临时记忆。
- 核心记忆：由智能体维护的事实类记忆，但是对于当前对话，只取有关联的事实用作上下文。
- 历史对话记录：包括所有完整的历史对话记录，在必要是搜索使用。
- 压缩类记忆：存储在外部的、经过提炼且加了索引的知识和记忆，通常用向量数据库存储，在查询后把信息放到上下文中。比历史对话记录更高效。
```
Types of memory from computer engineering:
· Message buffer: The current conversation content corresponds to the temporary memory of anthropomorphic memory.
· Core memory: A factual memory maintained by the agent, but for the current conversation, only relevant facts are used as context.
· Historical Conversation History: Includes all complete historical conversation records, searched and used if necessary.
· Compressed memory: External, refined and indexed knowledge and memory, usually stored in a vector database, and the information is put into context after querying. More efficient than historical conversation records.
```

EverMemOS主要使用的是拟人化记忆模式，结合了工程类记忆的效率实践，设计了多层次、多类型的记忆结构。存储记忆的大致流程是：
1. 识别对话中的关键信息，提炼成记忆单元；
2. 按对话主题、对话用户，与之前的记忆整合，梳理出脉络和用户画像；
3. 建立记忆的关键词和索引，用于快速召回；
```
EverMemOS mainly uses anthropomorphic memory mode, combined with the efficiency practice of engineering memory, and designs a multi-level and multi-type memory structure. The general process of storing memories is:
1) Identify key information in the dialogue and refine it into memory units;
2) According to the dialogue topic and dialogue users, integrate with the previous memory, sort out the context and user portrait;
3) Establish memorized keywords and indexes for quick recall;
```
## 如何调用记忆
调用记忆的核心挑战是如何避免因为记忆过多、查询过慢导致响应时间变长。对于需要快速响应的对话，EverMemOS直接使用RRF融合算法（Reciprocal Rank Fusion）；对于复杂的场景，Agent会生成2-3个互补查询，补全缺失的信息，提升复杂问题的覆盖面，然后并行查询出需要使用的记忆。
```
How to call memory
The core challenge of calling memory is how to avoid long response times due to too many memories and slow queries. For conversations that require a quick response, EverMemOS directly uses the RRF Rank Fusion algorithm. For complex scenarios, the agent generates 2-3 complementary queries to complete the missing information, improve the coverage of complex problems, and then query the memories that need to be used in parallel.
```

召回多层次的记忆后，再与当前对话内容拼接，整合成完整的上下文，给出最终的回复。一个典型的例子是你让AI给你推荐饮食，AI可以联想到你前几天做了牙科手术，从而有针对性的调整建议。
```
After recalling the multi-level memory, it is then spliced with the current conversation content and integrated into a complete context to give the final response. A typical example is when you ask AI to recommend a diet for you, which can be associated with the fact that you had dental surgery the other day to make targeted adjustments.
```

通过 "结构化记忆 → 多策略召回 → 智能检索 → 上下文推理" 的记忆和召回路径，EverMemOS在LoCoMo评测里达到了 92.4% 的推理准确率**，**为目前最佳。长时间的记忆里、高准确率的召回率，是AI助理和AI机器人的必需能力，2025年是Agent的元年，2026会成为记忆的元年。
```
Through the memory and recall paths of "Structured Memory→ Multi-Policy Recall→ Intelligent Retrieval →Contextual Reasoning", EverMemOS achieved an inference accuracy of 92.4% in the LoCoMo evaluation, which is the best at present. In long-term memory, high accuracy recall is a necessary ability for AI assistants and AI robots, 2025 is the first year of Agent, and 2026 will become the first year of memory.
```


![image.png](/static/img/71966cc0cac578a5d4246c11601c65e3.image.webp)

[github](https://github.com/EverMind-AI/EverMemOS/tree/main)

企业级智能记忆系统

在与 AI 多轮交互获得理想答案后，应进一步提炼出一个“一步到位”的高质量提示词，并持续积累和优化这类提示词，以提升未来同类问题的解决效率与精准度。



具体而言：
1. 反思性提炼：当通过多轮对话得到满意结果时，主动追问“若要你一步生成这个答案，我当初该怎么提问？”，从而逆向推导出更精准的初始提示词。
2. 提示词资产化：将高频问题对应的优质提示词沉淀为个人知识资产，形成“问题–提示词–理想回答”的映射库。
3. 持续迭代优化：在后续使用中不断调整提示词的细节（如约束条件、输出格式、角色设定等），使其更贴合实际需求，减少交互轮次，提高 AI 输出质量与效率。



## 示例

1. 假设我们下次再执行同样的任务，为了能够缩短我们的交互次数或对话轮数，我应该给你怎样的提示词？给出详细、精准的提示词，附理由
2. 如果你一步到位生成最终的回答，我给你的提示词应该怎么写？给出详细、精准的提示词，附理由

提示词优化

## 背景

作者：陈行甲

一切过往皆财富

![](https://ts1.tc.mm.bing.net/th/id/R-C.27c780bd5906d334b444eb4f5d5b4078?rik=DYjND3D2ZBD0Sg&riu=http%3a%2f%2fi3.hexun.com%2f2021-04-03%2f203344895.png&ehk=Q%2byulZP2lGI8onMFKii0Vcq9nGYaiJCTIXUIKHmoWrU%3d&risl=&pid=ImgRaw&r=0&sres=1&sresct=1)



一次刷视频，看到了这样的新闻，顿时感觉，是什么样的作家，什么样的书籍，一个农民会跑到签售会。这样的举动，我心里感觉，农民大叔是一个不一样，心怀很多期待，令人敬佩。

![image.png](/static/img/fa23494bd22396cfc1332853f8f66581.image.webp)

这也让我再次感受到，读书的伟大，不管在做着什么样的工作，都可以去读书，去感受另外的世界。这位农民大叔，被现场工作发现之后，新书发布会的陈行甲亲切地问候，而且送上了自己的联系方式，这个作者是真的平易近人。

## 人物了解

起初，看到视频，我没有去仔细去了解，但是，在我上一个书籍看完之后，看到了《陈行甲的人生笔记》的推荐，遂去点开读了一些，然后又去查看了这个作者的一些资料。

在近些年看书的时候，习惯会一边看一边去查这个作者的信息，主要是受b站up主：姜Dora的影响。

陈行甲，巴东一名最高政治官员

## 读书笔记
- 这本书的主人在他的每个人生阶段都充满不自信、惶恐和挣扎，同时也从未放弃爱和希望。无数次地在不自信中寻找爱和希望，在找到爱和希望后又会被另一个不自信包围。周而复始，循环向前。我相信这是每个人的人生缩影。
- 人活着就是含辛茹苦。世事艰难让我们很多人披上了心灵的铠甲，慢慢远离自己的内心，变得世故和冷漠。
- 我们这些穷乡亲，在等待着我们！他们期待的目光，早已穿越万水千山、风霜雨雪，我们奔向他们的脚步，大地会聆听。人间最冷的不是冰寒，而是麻木。你不是太阳，但你可以发出比太阳更温暖的光！
- 霞抄写的诗《有一种缘分》截取：

```shell
伤感是你含泪的眼眸
沉重是你燃烧的烟头
假如有一天我能读懂你
面对落日不再回首
共承风雨不是陌路
```
- 我们就像青春岁月里两只孤单的飞鸟，在这片水域遇见，彼此触碰到了对方的羽毛，看到了对方眼神中清澈的光。茫茫的天空，哪里是我们的去处，我们都不知道，可是这并不影响我们彼此简单又欢欣的流连缱绻
- 霞热烈地回应了我，霞在信中流着泪答应了我的求爱，霞在信中拥抱了我。我们的第一次拥抱，是隔空在信中完成的。我和霞的爱情就这么正式开始了。
- 是霞，是霞，是我的霞又回来了
- 逛完市场回家，我从后面抱住了霞，霞回过身抱住我，我们热烈地拥抱，这是我们第一次真正意义上的拥抱，百感交集，我们俩都留下了激动的泪水。
- 1996年1月18日，这一天居然是我的生日，我的25岁生日。后来到单位上请婚假的时候，张阿姨看了我的结婚证，说小陈你结婚时满了25岁，算是晚婚，可以请18天婚假了，否则只能请3天假
- 霞很坚定地跟我说行甲咱们不能着急，你自己可能没感觉到，但是，我从旁边看你每天都在进步，我陪着你，你住多久我陪多久，咱们安安心心的好不好。`此句摘自，在陈行甲因抑郁症住院想要出院时`
- 霞叮嘱我一定要注意安全，她说：行甲我从来没有指望过你飞黄腾达，我只是要求你一定要活着回来。不要担心我和儿子，我和儿子都为你感到骄傲。你千万保重好自己。`此句摘自，陈行甲反腐时受到不法分子威胁时`
- 生活有其自身的逻辑，那些不经意间的种子，那些没有企图的浇灌，说不准在什么时候会有一阵春风拂过就出土了。
- 行甲你好！看了你的演讲，十分感动，也真正理解了你的一切举动！一个字，真！两个字，纯真！三个字，真善美！一个人只有这样活着，才真正有价值，才真正对社会有贡献！`此句摘自，陈行甲在《我是演说家》的演讲后，施老师给陈行甲发的信息`
- 面临选择时我们总是斤斤计较于每一个方面。如果我们在对我们不那么重要的方面让让步，然后力争在对自己的人生分量很重的选择上胜出，我们的人生是否会精彩许多呢？
- 虽说都是农村，不得不承认他们的农村和我们的农村不像是一个意义上的概念。`此句摘自，美国的农村与中国农村的对比`
- 此时的我有一种莫名的感动，觉得自己就站在天与地的交接处，谁说命运和理想是天和地的平行，只要把天和地都装在心里，再长的平行线也有相交的时候。
- 你不是太阳，但你可以发出比太阳更温暖的光！
- 记得小时候村子里的一些贫穷的家庭，那些成天里话没个好腔，脸没个好相，看什么都不顺眼，总在抱怨争吵的家庭，过了多少年仍是穷得叮当响。倒是那些家庭团结和气，勤扒苦挣的，慢慢地都走出了贫困。
- 中国是个人情社会，完全出于感情的人情往来是社会的黏合剂，是美好的。我想说的是我希望和大家有这种美好的，没有负担的交往。
- 我在县党建工作会上谈学习习**“心中有党，心中有民，心中有责，心中有戒”的要求时，深入讲了我的理解：我们党员干部要做到心中有戒，新必须心中有止。止是上限，戒是底线，没上限的人往往没有底线。
- 当你真正把一件事情想得澄澈透明，你甚至会觉得整个宇宙都在帮你论证这件事情的合理性。
- 推荐一本书：德鲁克-《管理自己》
- `任何通往光明前景的道路都不是笔直的。你做的这些探索是有意义的，不要急，理清头绪，一步步地扎实，每天进步一点点，每月进步一点点，坚持下去就好。`
- 国际上通行的KSA教育理论。Attitude表示的是孩子通过审美教育获得的对于美好事物的体悟能力，通过开阔视野获得的对于世界的好奇心，通过梦想激励获得的对于人生成长的内动力。
- 我感激那些与我同行的人，感谢那些为我故障的路人。而与我渐行渐远的朋友，我也微笑作别，尊重彼此的选择，不道德绑架。人生是一个过程而不是结果，我对我的选择很坦然。“洛阳亲友如相问，一片冰心在玉壶”
- 我们每一个凡夫俗子的人生大部分都在自发而不是自觉的状态下度过，我们是在对自己的重新审视、重新叙述当中理解自己的。
- 写书不是为了让别人记得你，而是你要为自己留住自己。
- 回顾过去并不是为了纠结于过去的是非曲直，而是为了更好地展望未来。
- 认清世界的真相但仍然热爱它，永远是一个望向未来的乐观者的信条
- 我们不该忘记自己走过的路，同情过的人，呼唤过的正义，渴求过的尊重，是这些东西构成了我们深植于生活世界的共通意义的根基。
- 人活到最后，要对天下说一声谢谢。曾经那么为难他的人，作为一个人类的个体，不管怎样，都丰富了他对人类的认知，一切过往都是财富

## 后感

陈先生做的事情，彻彻底底地为老百姓，为人民群众，大义之人。在读过了这本书之后，颇受感动，终于知道为什么，他的书，会被农民伯伯喜欢。

在陈先生的一生中，两位女人发挥了很大的作用，一个给予了他生命，一个拯救了他的生命。在这种情况下，才会对人生看的那么透彻，他的坚韧、善良，无比令人敬仰。

在看陈先生与霞女士的爱情故事时，特别像路遥的《平凡的世界》，那个年代爱情特有的，淳朴、纯真、浪漫。陈先生如今的成就，离不开霞女士的奉献、帮助。是我心中最美的，爱情的样子。

看我这本书，最大的感受，就是一切过往皆财富。不管过去经历过什么，自己还会乐观，怀着善良、淳朴的心，看待这个世界。为自己留住自己，勇往直前吧。


ps： 小小地期待，这本书，可以在未来拍成电影。👏🏻~~ 2025.7.27

陈行甲人生笔记-读书后感

![WechatIMG480.jpg](/static/img/1580ac1f5c76006f1962726322bea97c.WechatIMG480.webp)

## 介绍
作者：蔡崇达

是在看姜Dora的视频的时候，对他的访谈，感觉这个人特别有意思，这是看他写的第二本书

[人要到能托举和滋养自己的关系里去，什么样的人最养你？【蔡崇达x姜Dora】]( https://www.bilibili.com/video/BV1QPBFY9ELa/?share_source=copy_web&vd_source=ef6c842229f8fecfc4dcb8aa804c79b8)




## 好句

- 年纪越大越明白，没心没肺的开心，真实一种能力
- 发呆真的挺好的，可以发现脑子里藏着那么多自己都不知道的想法，可以看到其他人看不到的奇奇怪怪的事情——任何寻常的细节，稍一琢磨，都可以发现，藏着许多不那么寻常的好玩。
- 身体明明还在，但人就是不在了。
- 这世间总有某部分是在意着我的，这世界总有部分是试图陪伴我、和我交朋友的。只有一直知晓并且笃定这世界有着这样的部分，作为人，因此，才能够真正懂得并有能力学习珍惜他人和这世界。或许，也才有能力真正学习去珍惜自己。
- 我们看你老低着头，想说，如果你养了鸽子，可能就会喜欢抬头看看天吧
- 在失去那群鸭子后，我察觉到一个事情：如果没有名字，再宝贵的东西，都只是东西
- 或许人只要心里安定，日子再苦都会是开心的
- 黒咪真的尽力了，我父亲真的尽力了
- 现在身体还在，所以你赶紧去看看她。看的仔细点，这样以后你想念她的时候，还会记得她的样子。
- 当然啊，人永远对一些事情不习惯的，多老都不习惯的。
- 只要认定是家了，即使再不好，它们也会回来的。
- 总会有孤单的时候，毕竟岁月这么漫长

## 感受

1. 蔡崇达的书籍，虽然有点悲伤，但是更有一些治愈，看他的书，明白一件事儿：“根”。人的根在家乡，在童年时代，我觉得这个是走向未来的动力。家乡的情、亲人的情，这些东西在日夜繁忙的社会中，是一口舒心凉茶。让人踏实。
2. 人生最浪漫的事情，就是你讲你自己的故事讲给别人听。不管是通过书籍、视频、照片还是其他方式，能被记录下来，是最有价值的。每日繁忙的工作，日复一日的做地铁去上班，过程难免会厌倦。记录当下，过好当下，是最开心，也是最应该开心的事情。
3. 心怀感恩。小的时候有幸被很多人喜爱，长大之后，可能会发现疼爱你的人少了，但是那些美好的记忆，化作无形的力量，在我遇到困难的时候发挥隐形的作用，心怀感恩，爱意满满。



## 动机
写这篇文章，是因为自己在每周的时候都会看阮一峰、阿猫的博客。平常加班的时候，根本会静下心来去读书，去写一个自己的感受。人真的在繁忙的工作下，还需要去腾出时间，让自己好好休息。好的休息是为了更好的前行

希望以后，可以多写写自己的成长和感受，加油！