逻辑分区的特点，和比物理分区的优势

https://wiki.archlinux.org/title/LVM
更灵活
1. 使用任意数量的磁盘作为一个大磁盘。
2. 将逻辑卷扩展到多个磁盘上。
3. 创建小的逻辑卷，并在卷被填满时“动态地”调整其大小。
4. 调整逻辑卷的大小，而不考虑它们在磁盘上的顺序。它不依赖于LV在VG中的位置，没有必要确保周围的可用空间。
5. 在线调整/创建/删除逻辑卷和物理卷。它们的文件系统仍然需要调整大小，但有些(如ext4)支持在线调整大小。
6. 将服务正在使用的LV在线/热迁移到不同的磁盘，而无需重新启动服务。
7. 快照允许您备份文件系统的冻结副本，同时将服务停机时间保持在最低限度。
8. 支持各种设备映射器目标，包括透明的文件系统加密和常用数据的缓存。这允许创建一个具有(一个或多个)物理磁盘(通过LUKS加密)和LVM的系统，以便轻松调整和管理单独的卷(例如，for /， /home，/backup等)，而无需在启动时多次输入密钥。

逻辑分区里的概念

PV
VG
LV
PE
LE

物理卷(PV) Unix块设备节点，可用于LVM存储。例如:一个硬盘，一个MBR或GPT分区，一个环回文件，一个设备映射设备(例如dm-crypt)。它承载一个LVM头文件。

卷组(VG) pv的组，作为lv的容器。pe从VG分配给LV。

逻辑卷(LV)“虚拟/逻辑分区”，位于VG中，由pe组成。lv是类似于物理分区的Unix块设备，例如，它们可以直接用文件系统进行格式化。

物理范围PE (Physical extent) PV中可分配给LV的最小连续范围(默认为4mib)。把pe看作pv的一部分，可以分配给任何LV。

常用命令

pvdisplay
vgdisplay
lvdisplay
pvresize /dev/sda1
vgdisplay| grep Free
lvextend -L +5G(replace by Free space) /dev/haha_vg/lv_root
resize2fs /dev/mappaer/xxxxx (df -h 要生效，要resi

网址URL中特殊字符转义编码

在官网上下载所需版本的驱动包，5.1.0-6.6.0

https://www.mellanox.com/
MLNX_OFED_LINUX-5.1-0.6.6.0-ubuntu20.04-x86_64.tgz

解包

tar zxvf MLNX_OFED_LINUX-5.1-0.6.6.0-ubuntu20.04-x86_64.tgz

添加对指定kernel 的支持，执行./mlnx_add_kernel_support.sh ，生成新包 --k64.tgz

./mlnx_add_kernel_support.sh -m /vob/MLNX_OFED_LINUX-5.1-0.6.6.0-ubuntu20.04-x86_64 -k 5.4.0-64-generic -s /usr/src/linux-headers-5.4.0-64-generic -t /vob/t/ -n MLNX_OFED_LINUX-5.1-0.6.6.0-ubuntu20.04-x86_64-ext-k64 

解压新包，并执行./mlnxofedinstall

tar zxvf MLNX_OFED_LINUX-5.1-0.6.6.0-ubuntu20.04-x86_64-ext-k64.tgz
./mlnxofedinstall --dpdk --without-dkms --force --without-depcheck  -k 5.4.0-64-generic -s /usr/src/linux-headers-5.4.0-64-generic

获取官方 kernel 指定版本头文件

先安装kernel 头文件

sudo apt-get install linux-headers-5.4.0-65-generic

内核头文件在：/usr/src/ ,去打包

cd /usr/src/
tar -zcvf linux-headers-5.4.0-65-generic.tar.gz ./linux-headers-5.4.0-65-generic
tar -zcvf linux-headers-5.4.0-65.tar.gz ./linux-headers-5.4.0-65

将头文件包放至需要集成编的项目中一起编译。

kernel 相关设置和查询命令

安装指定版本kernel

apt-get install linux-image-5.4.0-65-generic

保持kerknel 版本不升级

apt-mark hold linux-image-5.4.0-65-generic linux-headers-5.4.0-65-generic

查看已安装 版本

root@gua-vm2:/vob# dpkg --get-selections | grep linux-image
linux-image-5.4.0-52-generic            deinstall
linux-image-5.4.0-53-generic            deinstall
linux-image-5.4.0-56-generic            deinstall
linux-image-5.4.0-58-generic            deinstall
linux-image-5.4.0-59-generic            deinstall
linux-image-5.4.0-60-generic            deinstall
linux-image-5.4.0-62-generic            deinstall
linux-image-5.4.0-65-generic            install
l

构造函数

构造函数（constructor），类定义中的初始化方法，命名为_init_。然而，构造函数不同于普通方法的地方在于，将在对象创建后自动调用它。

析构函数

Python提供了魔法方法del，也称作析构函数（destructor）。这个方法在对象被销毁（作为垃圾被收集）前被调用，但鉴于你无法知道准确的调用时间，建议尽可能不要使用del。

重写构造方法

重写的构造函数必须调用其超类的构造函数，以确保基本的初始化得以执行。为此，有两种方法：调用未关联的超类构造函数，以及使用函数super。super().init()

def __init__(self): 
    super().__init__()

python 只要求对象遵循特定的协议

在Python中，协议通常指的是规范行为的规则，有点类似于第7章提及的接口。协议指定应实现哪些方法以及这些方法应做什么。在Python中，多态仅仅基于对象的行为（而不基于祖先，如属于哪个类或其超类等），因此这个概念很重要：其他的语言可能要求对象属于特定的类或实现了特定的接口，而Python通常只要求对象遵循特定的协议。因此，要成为序列，只需遵循序列协议即可。

__len__(self)
__getitem__(self, key)
__setitem__(self, key,value)
__delitem__(self, key)

存取方法

通过存取方法定义的属性通常称为特性（property）。 get(),set()
函数 property,通过调用函数property并将存取方法作为参数（获取方法在前，
设置方法在后）创建了一个特性，然后将名称size关联到这个特性。这样，你就能以同样的方式对待width、height和size，而无需关心它们是如何实现的.

class Rectangle: 
    def __init__ (self): 
        self.width = 0 
        self.height = 0 
        def set_size(self, size): 
        self.width, se

多态、封装、方法、属性、超类和继承

多态

每当无需知道对象是什么样的就能对其执行操作时，都是多态在起作用

>>> 'abc'.count('a') 
1 
>>> [1, 2, 'a'].count('a') 
1 

如果有一个变量x，你无需知道它是字符串还是列表就能调用方法count：只要你向这个方法提供一个字符作为参数，它就能正常运行。
多态形式是Python编程方式的核心，有时称为鸭子类型。这个术语源自如下说法：“如果走起来像鸭子，叫起来像鸭子，那么它就是鸭子。”有关鸭子类型的详细信息，请参阅http://en.wikipedia.org/wiki/Duck_typing。

封装

封装（encapsulation）指的是向外部隐藏不必要的细节。这听起来有点像多态（无需知道对象的内部细节就可使用它）。这两个概念很像，因为它们都是抽象的原则。它们都像函数一样，可帮助你处理程序的组成部分，让你无需关心不必要的细节。但封装不同于多态。多态让你无需知道对象所属的类（对象的类型）就能调用其方法，而封装让你无需知道对象的构造就能使用它。
如果
o将其名称存储在全局变量global_name中，如果尝试创建多个OpenObject对象，将出现问题，因为它们共用同一个变量。避免干扰全局变量，就需要将名称“封装”在对象中。使用属性而非全局变量。

类

在Python中，表示类约定使用单数并将首字母大写，如Bird和Lark。

在较旧的Python版本中，类型和类之间泾渭分明：内置对象是基于类型的，而自定义对象是基于类的。因此，你可以创建类，但不能创建类型。在较新的Python 2版本中，这种差别不那么明显。在Python 3中，已不再区分类和类型了。

隐藏

如果能直接访问ClosedObject（对象c所属的类）的属性name，就不需要创建方法setName和getName了。关键是其他程序员可能不知道（也不应知道）对象内部发生的情况。例如，ClosedObject可能在对象修改其名称时向管理员发送电子邮件。这种功能可能包含在方法set_name中。但如果直接设置c.name，结果将如何呢？什么都不会发生——根本不会发送电

Python 断言 并行迭代 异常

断言 assert

如果知道必须满足特定条件，程序才能正确地运行，可在程序中添加assert语句充当检查点，这很有帮助。还可在条件后面添加一个字符串，对断言做出说明。

>>> age = -1 
>>> assert 0 < age < 100, 'The age must be realistic' 
Traceback (most recent call last): 
 File "<stdin>", line 1, in ? 
AssertionError: The age must be realistic

并行迭代 用内置函数 zip

有时候，你可能想同时迭代两个序列。假设有下面两个列表：

names = ['anne', 'beth', 'george', 'damon'] 
ages = [12, 45, 32, 102] 

一个很有用的并行迭代工具是内置函数zip，它将两个序列“缝合”起来，并返回一个由元组组成的序列。返回值是一个适合迭代的对象，要查看其内容，可使用list将其转换为列表。

>>> list(zip(names, ages)) 
[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]

“缝合”后，可在循环中将元组解包。

for name, age in zip(names, ages): 
    print(name, 'is', age, 'years old') 

函数zip可用于“缝合”任意数量的序列。需要指出的是，当序列的长度不同时，函数zip将在最短的序列用完后停止“缝合”。

>>> list(zip(range(5), range(100000000))) 
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

迭代时获取索引

使用内置函数enumerate。

for index, string in enumerate(strings): 
    xxxxxx

用while 等待用户输入

可以使用循环来确保用户输

函数open的参数mode的最常见取值

显式地指定读取模式的效果与根本不指定模式相同。写入模式让你能够写入文件，并在文件不存在时创建它。
独占写入模式更进一步，在文件已存在时引发FileExistsError异常。在写入模式下打开文件时，既有内容将被删除（截断），并从文件开头处开始写入；
如果要在既有文件末尾继续写入，可使用附加模式。
'+'可与其他任何模式结合起来使用，表示既可读取也可写入。例如，要打开一个文本文件进行读写，可使用'r+'。（你可能还想结合使用seek，详情请参阅本章后面的旁注“随机存取”。）请注意，'r+'和'w+'之间有个重要差别：后者截断文件，而前者不会这样做。默认模式为'rt'.

每当调用f.write(string)时，你提供的字符串都将写入到文件中既有内容的后面。

>>> f = open('somefile.txt', 'w') 
>>> f.write('Hello, ') 
7 
>>> f.write('World!') 
6 
>>> f.close() 

读取也一样简单，只需告诉流你要读取多少个字符（在二进制模式下是多少字节），如下例所示：

>>> f = open('somefile.txt', 'r') 
>>> f.read(4) 
'Hell' 
>>> f.read() 
'o, World!

f.read() 读取了文件中余下的全部内容

三个标准流

模块sys的一节中，提到了三个标准流。
sys.stdin
一个标准数据输入源是sys.stdin。当程序从标准输入读取时，你可通过输入来提供文本，也可使用管道将标准输入关联到其他程序的标准输出.
sys.stdout
提供给print的文本出现在sys.stdout中，向input提供的提示信息

使用模块

模块是为了用来下定义和重用的。
导入放在c:/python 下的hello.py 作为模块使用。模块导入只导入一次，第二次什么也不会发生，打破互相导入的死循环。如果一定要重新加载模块，使用importlib.reload()

>>> import sys
>>> sys.path.append('C:/python')
>>> import hello 
Hello, world!

查看系统查找的全部路径有什么，除了sys.path , 标准做法是将模块所在的目录包含在环境变量PYTHONPATH中。

>>> import sys, pprint 
>>> pprint.pprint(sys.path) 
['C:\\Python35\\Lib\\idlelib', 
 'C:\\Python35', 
 'C:\\Python35\\DLLs', 
 'C:\\Python35\\lib', 
 'C:\\Python35\\lib\\plat-win', 
 'C:\\Python35\\lib\\lib-tk', 
 'C:\\Python35\\lib\\site-packages']

包含测试代码的模块，应该将代码放入if 条件中

if __name__ == '__main__': test()

使用包

模块存储在扩展名为.py的文件中，而包则是一个目录。要被Python视为包，目录必须包含文件init.py。如果像普通模块一样导入包，文件init.py的内容就将是包的内容。

模块包含什么

dir

要查明模块包含哪些东西，可使用函数dir，它列出对象的所有属性（对于模块，它列出所有的函数、类、变量等）。

[i for i in dir(copy) if not i.startswith("_")]
['Error', 'copy', 'deepcopy', 'dispatch_table', 'error']

all

>>> copy.__all__ 
['Error', 'copy', 'deepcopy'] 

all 的设置是在模块copy 是定义的

__all__ =

文档字符串

除了# 注释，有另一种编写注释的方式，就是添加独立的字符串。在有些地方，如def语句后面（以及模块和类的开头，），添加这样的字符串很有用。放在函数开头的字符串称为文档字符串（docstring），将作为函数的一部分存储起来。下面的代码演示了如何给函数添加文档字符串：

def square(x): 
 'Calculates the square of the number x.' 
 return x * x 

可以像下面这样访问文档字符串：

>>> square.__doc__ 
'Calculates the square of the number x.'

收集参数

单星号 * （元组）
前面有星号的参数将被放在元组中。
因此星号意味着收集余下的位置参数。如果没有可供收集的参数，params将是一个空元组。

>>> print_params_2('Nothing:') 
Nothing: 
() 

与赋值时一样，带星号的参数也可放在其他位置（而不是最后），但不同的是，在这种情况下你需要做些额外的工作：使用名称来指定后续参数。单星号不会收集关键字参数。

>>> def in_the_middle(x, *y, z): 
... print(x, y, z) 
... 
>>> in_the_middle(1, 2, 3, 4, 5, z=7) 
1 (2, 3, 4, 5) 7

双星号 ** （字典）
要收集关键字参数，可使用两个星号。

>>> def print_params_3(**params): 
... print(params) 
... 
>>> print_params_3(x=1, y=2, z=3) 
{'z': 3, 'x': 1, 'y': 2} 

如你所见，这样得到的是一个字典而不是元组。可结合使用这些技术。

def print_params_4(x, y, z=3, *pospar, **keypar): 
 print(x, y, z) 
 print(pospar) 
 print(keypar) 

其效果与预期的相同。

>>> print_params_4(1