本文记录一些日常通用的笔记，定期整理入其他的路径下

日常笔记

  • Linux 中，realpath 命令可显示文件绝对路径
  • jsonl 文件中每一行是一个 json 字符串
  • Linux 中，汇总显示当前文件夹下占用大小：du -bsh
    • -s 参数表示总结性展示一个数字即可
  • Python 中，函数内部若不使用 return 而是 ...，则表示返回 None
  • Python 中，x = a or b 等价于 x = a if a else b

arXiv 提交论文

  • 新作者一般需要找人帮忙背书才能提交到 arXiv
  • 背书人一般需要在相关领域上传至少 3 篇左右文章到 arXiv 上才可以
  • 帮人背书：

名词释义

FDE

  • FDE（Forward Deployed Engineer）：前线/前置部署工程师，也叫前沿部署工程师
    • 最早由美国企业 Palantir 提出，现在是 AI 大模型时代非常核心的岗位，字节、OpenAI、Google 等都在大规模招聘
  • 简单理解：
    • 派驻到客户现场、打通技术和真实业务场景的复合型工程师
    • 集工程师+产品经理+解决方案架构师+交付顾问于一身，核心不是做功能，而是让技术真正给客户业务创造价值
  • 思考：不管技术怎么迭代（传统软件 到 AI 大模型），都需要有人深入业务现场、快速解决真实痛点、落地可产生价值的技术方案，这就是 FDE 的长期价值

reStructuredText（.rst）文件简介

  • .rst 是 reStructuredText 的缩写，一种轻量级标记语言，主要用于书写技术文档、API 文档和说明手册，是 Python 社区 Sphinx 文档工具的默认格式

主要特点

  • 比 Markdown 功能更强：支持标题层级、表格、代码块、提示框、交叉引用等

  • 结构化文档友好：适合中大型文档、多章节、自动生成 HTML/PDF

  • Sphinx + Docutils 渲染：广泛用于 Python 官方文档、开源库文档（NumPy、Requests 等）

  • 示例：

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

    =========
    项目文档
    =========

    简介
    ----
    这是一个 **reStructuredText** 示例

    .. note::

    这是一个注意事项

    .. code-block:: python

    def hello():
    	print("Hello, world!")

  • 常见用途

    • Sphinx 项目文档（index.rst、conf.py 配合）
    • Python 包说明文档
    • 技术规范、用户手册（VeRL 项目使用的就是 .rst 格式）

  • 一句话对比 .md 和 .rst

    • Markdown = 简单快捷（README / 博客）
    • RST = 功能完整（正式、结构化技术文档）

U盘做系统盘后空间会减少，本文给出恢复U盘空间的方法
U盘做系统时会自动隐藏部分空间，用于放置启动文件，这些被隐藏的空间用普通的格式化方法无法恢复

Windows

  • 第一步：清除 U 盘： cmd 输入diskpart

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # show all disks
    list disk
    # select target disk(our usb flash disk)
    select disk=n 
    # show all disks again
    # make sure we have chosen the right disk
    # there will be a star in choosed disk
    list disk
    # clean the disk
    clean

  • 第二步：用任意方式格式化 U 盘

由于 Windows10 过大，install.win 文件超过 4GB，常规的 U 盘启动盘制作都是面向 FAT 分区方式的，该方式无法存储超过 4GB 的文件，本文给出一种解决方案

Windows10 U 盘启动盘制作方法：

  • 打开 UltraISO 制作镜像
    • 注意不勾选 create boot partition 选项，否则 U 盘中会隐藏分区，看不到文件
  • 使用 convert H:/fs:ntfs（H 为 U 盘盘符，ntfs 可支持 4GB 以上的文件）
  • 解压 ISO 文件并替换 U 盘中的 ./sources/install.win 文件（因为该文件大于 4GB，FAT 分区格式无法写入）

维度确定

规则为从前到后，参数由外到内，由行到列

  • values.reshape(2,3) 表示二行三列(2,3)
  • values.reshape(4,2,3) 表示四个(2,3),四个两行三列
  • values.reshape(5,4,2,3) 表示五个(4,2,3)

reshape本质理解

实际上numpy多维数组变化维度时，内存数据没有变化，只是有一个shape参数指明维度即可

  • 每次变化维度的过程可以理解为先将维度还原到(参考：维度确定)一维数组，然后再转化成制定的目标维度
  • 返回的是新对象，但是新老对象数据共享，只有shape等内部属性不一样，所以reshape操作不浪费内存，也不耗费时间，但是需要注意数据共享可能造成的误操作
    • 测试说明： 使用DataFrame.values.reshape()生成的新对象内存数据不共享

特殊参数 “-1“

用于智能补齐某一维度，只能有一个参数为-1

  • 除了-1参数外，其余的部分一定要能够被整除
  • -1本身占用一个维度
  • 假设一维数组维度为12
    • (-1, 2) <==> (6, 2) <==> (6, -1)
    • (-1) <==> (12)

用于矩阵维度的转换

transpose函数的使用

  • 用法说明

    1
    nums.transpose(dims)
    • nums为np.ndarray类型的对象
    • dims为表示维度排列的tuple
      • 对于二维矩阵,只有0, 1两个维度,所以只能是(0,1), (1,0)
      • 三维矩阵,有0,1,2三个维度,所以可以是是(0,1,2)的所有全排列,共6个

简单易懂的解释

  • 只改变维度, 每一维度对应的数据不会变, 比如图片的shape为: (28, 28, 3),那么无论怎么变化维度, 变换后的数据中维度大小为3的那个维度都是表示通道, (28,28)总是表示图片的每个通道的数据
  • 原始numpy.ndarray,shape为(2,3,4)
    • .transpose((0,1,2)): shape为(2,3,4), 不变
    • .transpose((1,0,2)): shape为(3,2,4)
    • .transpose((2,1,0)): shape为(4,3,2)
  • 测试代码
    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
    import numpy as np

    origin = np.random.random_integers(1, 100, (2,3,4))
    print("-"*20 + "origin")
    print(origin)
    print("-"*20 + "(0,1,2)")
    print(origin.transpose((0,1,2)))
    print("-"*20 + "(1,0,2)")
    print(origin.transpose((1,0,2)))
    print("-"*20 + "(2,1,0)")
    print(origin.transpose((2,1,0)))

    # Output:
    --------------------origin
    [[[50 36 80 53]
      [45 45 94 91]
      [49 29 69 53]]

     [[85 83 61 18]
      [16 89 80 60]
      [99 13 36 40]]]
    --------------------(0,1,2)
    [[[50 36 80 53]
      [45 45 94 91]
      [49 29 69 53]]

     [[85 83 61 18]
      [16 89 80 60]
      [99 13 36 40]]]
    --------------------(1,0,2)
    [[[50 36 80 53]
      [85 83 61 18]]

     [[45 45 94 91]
      [16 89 80 60]]

     [[49 29 69 53]
      [99 13 36 40]]]
    --------------------(2,1,0)
    [[[50 85]
      [45 16]
      [49 99]]

     [[36 83]
      [45 89]
      [29 13]]

     [[80 61]
      [94 80]
      [69 36]]

     [[53 18]
      [91 60]
      [53 40]]]

与reshape的区别

reshape的用法:
1
nums.reshape(shape)
* `nums`为`np.ndarray`类型的对象
* `shape`为表示维度排列的`tuple`
    * `shape`必须与原始`nums.shape`兼容,即每个`shape`元素相乘的结果相等
  • 从numpy中矩阵的存储开始讲起,numpy存储数据是C++的方式存储为一行的,然后分为不同shape以不同方式进行索引
  • reshape相当于是把原始数据先还原成一行(实际上没操作),然后再转变成指定shape的数据,本质上数据存储没变化,只是shape变了,以后索引方式也就变了
区别
  • reshape修改的只是shape,每个维度的意义变了
  • transpose修改的只是维度,同时shape跟着变化而已,每个维度的顺序变了,但是意义不会变

导入

1
from sklearn.feature_extraction.text import CountVectorizer

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 新建一个CountVectorizer对象，以下简称CV对象
vectoerizer = CountVectorizer(min_df=min_df, max_df=max_df, stop_words=stop_words, token_pattern=r"(?u)\b[\w-][\w-]+\b")

# 使用文本集合(一个文本的列表)训练当前CountVectorizer对象
# texts = ["this is a text", "this is another text"]
vectoerizer.fit(texts)

# 训练后可以读取当前CV对象信息
bag_of_words = vectoerizer.get_feature_names()

# 使用CV对象生成任意文本集合的信息，返回对象是文档到字典的数组统计(统计单词数量)
# 这里的texts不必要是之前使用过的，可以是新的文本集合，但是词典已经确定，不能再拓展了，不存在字典中的词直接忽略
X = vectoerizer.transform(texts)

# 使用X对象，toarray()将返回 term/token counts 矩阵，可直接用于TfidfTransformer等对象的训练
X.toarray()

重要参数说明

  • min_df: 用于排除出现次数太少的terms

    • min_df = 0.01 意味着将忽略出现在少于%1的文档中的词
    • min_df = 5 意味着将忽略只出现在5篇以下文档中的词，不包括5篇

  • max_df:

    • max_df = 0.50 意味着将忽略出现在多于%50的文档中的词
    • max_df = 25 意味着将忽略出现在25篇以上文档中的词，不包括25篇

Python也开始支持抽象类和多态了，但是Python的继承与Java有很多不同的地方

Python只有私有属性

(双下划线__属性)和公有属性(默认属性)，没有protected属性

  • 解决方案是Python提出命名时单下划线的属性为protected属性
    • 但是这只是一种口头约定，Python解释器并不做强制处理
  • 模块中的函数如果是单下划线开头的，那么该函数属于当前模块保护的
    • 此时某些IDE，比如Idea能够给出提示，但是用户仍可访问
    • 编程时建议将模块中不被调用的文件定义为_开头的，这样可以提示自己和别人当前函数不会在模块外被调用

Python类属性定义

属性定义在__init__函数中才能在对象中通过__dict__属性读取到

Python支持虚拟继承

可以欺骗编译器，不用真正实现虚拟基类的所有接口

都是强类型语言

这是他们的相同点，但我觉得写在这里是必要的

方法类型不同

  • Java中有一般方法(实例方法)，静态方法(static类名和对象均可直接调用)两种
    • Java中这两种方法也都可以被继承和隐藏 ，而不能被重写(隐藏的意思时换成对应的父类指针还能访问到父类的静态属性和方法)
  • Python中有一般方法(实例方法)，静态方法(@staticmethod类名和对象均可直接调用)和类方法@classmethod
    • 对@staticmethod方法的理解是，该方法与类密切相关，但是不需要访问这个类
    • Python的@staticmethod和@classmethod方法调用方式一样，唯一的区别在于@classmethod方法第一个参数必须是当前类(一般命名为cls)
    • Python中的这三种方法都可以被继承和重写

函数定义

  • 三种函数, 普通函数(实例函数), 类函数(classmethod), 静态函数(staticmethod)

普通函数

  • 无需任何装饰器
  • 无论如何定义,函数的第一个参数都会被当成实例对象本身(一般用self)

类函数

  • 装饰器 @classmethod
  • 无论如何定义,函数的第一个参数都会被当成实例对象本身(一般用cls)

静态函数

  • 装饰器 @staticmethod
  • 所有参数都是函数所有,不被占用

整体说明

  • 在 Python 中，-m 参数是一个非常有用的工具，它允许你将模块作为脚本运行，并且可以处理复杂的包结构。无论是运行标准库模块、自定义模块，还是与包结合使用，-m 参数都能简化操作。它的基本语法如下：

    1
    python -m module_name

  • 其中，module_name 是你要运行的模块名（不包含 .py 后缀）。Python 会在 sys.path 中查找该模块，并执行它

运行标准库模块

  • -m 参数常用于运行 Python 标准库中的模块。例如：

    1
    python -m http.server

  • 这会启动一个简单的 HTTP 服务器，默认监听在 8000 端口。http.server 是 Python 标准库中的一个模块，-m 参数让 Python 将其作为脚本运行

运行自定义模块

  • 你也可以使用 -m 参数运行自定义模块。假设你有一个项目结构如下：

    1
    2
    3
    4
    my_project/
        my_module/
            __init__.py
            main.py

  • 你可以在 my_project 目录下运行以下命令：

    1
    python -m my_module.main

这会执行 my_module/main.py 文件中的代码

运行包中的模块

  • 如果模块位于包中，-m 参数会自动处理包的导入路径。例如：

    1
    python -m package.subpackage.module

  • 这会执行 package/subpackage/module.py 文件中的代码

与 __main__.py 结合使用

  • 如果你有一个包，并且希望在运行包时执行特定的代码，可以在包目录下创建一个 __main__.py 文件。例如：

    1
    2
    3
    4
    my_package/
        __init__.py
        __main__.py
        other_module.py

  • 在 __main__.py 中编写你想要执行的代码，然后运行：

    1
    python -m my_package
    • Python

  • 这会执行 my_package/__main__.py 文件中的代码

与 python -c 结合使用

  • -m 参数也可以与 -c 参数结合使用，直接在命令行中运行模块。例如：

    1
    python -c "import os; print(os.getcwd())" -m http.server
    • 注：python -c "print('hello')"常常用来执行一个Python命令且不需要创建文件

没有Char类型

不同于C++和Java等语言,Python中没有字符char类型,只有字符串类型

关于字符类型的操作

  • 把长度为1的字符串当成字符来操作,比如函数ord(s)中只要s的长度为1(len(s) == 1)即可,否则ord函数抛出异常
    • 长度为1的字符串本质上还是一个字符串类型<type str>
  • 判断字符串某一位置的字符时直接比较即可,如： 
    1
    2
    3
    4
    5
    6
    7
    s = "12345"
    if s[2] == '2':
    	print s[3]
    # 等价于
    if s[2] == "2":
    	print s[3]
    # "2"和'2'都是<type str>类型的

整体说明

  • strip() 方法容易误解，使用时可能会发生未知问题，所以要小心
  • strip() 方法会从字符串的开头和结尾移除指定的字符，但它是逐个字符进行匹配的，而不是匹配整个子字符串
    • 即把输入参数当做一个字符集合（注意是一个字符集合而不是一个字符串）
    • 后续的文字只要在这个集合内都会被清除掉，知道遇到第一个不在这个字符集合的字符为止

具体示例分析

  • 下面是一个简单示例：

    1
    2
    string = "SYSTEM:You are an AI assistant. You will be given a task.  "
    print(string.strip('SYSTEM:'))
    • 上面的句子输出是 "ou are an AI assistant. You will be given a task. "（注意："SYSTEM:Y" 都被删除了，不仅仅是 "SYSTEM:"）

  • 具体来说，当执行 strip('SYSTEM:') 时：

    • strip() 会把 'SYSTEM:' 看作是一个字符集合 ：{'S', 'Y', 'S', 'T', 'E', 'M', ':'}
    • 从字符串开头开始，逐个检查字符是否在这个集合中：
      • 'S' 在集合中，移除
      • 'Y' 在集合中，移除
      • 'S' 在集合中，移除
      • 'T' 在集合中，移除
      • 'E' 在集合中，移除
      • 'M' 在集合中，移除
      • ':' 在集合中，移除
      • 'Y' 在集合中，移除（这里是 “You” 的 ‘Y’）
      • 'o' 不在集合中，停止移除，后续的字符都不再移除

  • 所以最终结果是 "ou are an AI assistant. You will be given a task. "

  • 如果你想移除特定的前缀字符串，应该使用：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 方法1：使用 removeprefix() (Python 3.9+)
    result = string.removeprefix('SYSTEM:')

    # 方法2：使用字符串切片
    if string.startswith('SYSTEM:'):
        result = string[7:]  # 'SYSTEM:' 长度为7

    # 方法3：使用 replace() (但要小心，会替换所有匹配项)
    result = string.replace('SYSTEM:', '', 1)  # 只替换第一个

  • 这样就能得到正确的结果："You are an AI assistant. You will be given a task. "