> 装了这么久的 ML/AI 爱好者，我发现我对 PyTorch 中的自动微分还是一知半解，停留在知道计算图和反向传播的概念，以及能看懂和小改别人写好的代码的水平。所以自觉还得再补补课。
> 
> ~~真实动机是前女友找到了国内的研发工作，马上要回国赚大钱了，我破防了~~
> 
> 之所以存在这样的认知断层，是因为介绍自动微分的时候一般是手动计算张量，然后给读者画个计算图；而真正干活的时候一般是写一个神经网络的类，这个类继承自 `torch.nn.Module`。
> 
> 这样一包装，承载微分的张量很少被点名取用；而计算过程被一刀两段，绝大多数计算包装在了这个类的 `forward()` 方法中，但是最后一步计算模型预测和训练目标的差异 (loss)，往往留在了训练的控制流中，让人以为两者之间有什么本质区别。
> 
> 其实不然——自动微分只针对 PyTorch 张量，`torch.nn.Module` 的实例是一个包含若干参数的函数，其参数要么是 `torch.nn.Parameter`，要么是其他含参的 `torch.nn.Module` 实例的参数，（用 `.parameters()` 方法取得，常见于 optimizer 的首个参数）。每次把训练输入张量带入这个函数，中间的数学计算就会被自动微分机制记录。对于自动微分来说，这些计算和最后对 loss 的计算没什么不同。
> 
> 这个道理其实在做《[**一个 PyTorch 机器学习项目长什么样**](what-a-PyTorch-project-looks-like)》这篇笔记的时候就应该理解，而实际上没有理解，说明——
> 
> - 一来信息和知识不是同一层面的概念，相同的信息嵌入在不同元信息中，可以给出不同深度的知识；
> - 再者费曼学习法虽然像实验记录一样有让人快速恢复学习进度的好处，但也有让人沉溺于流量，忘记学习本心的危险，戒之在躁。

一个机器学习项目的过程包括：准备数据、定义模型、训练、评估效果。先来个简单例子：

```python
import torch
from torch import data,nn,optim
# Data Preparation
dataset = data.Dataset(...)
trainloader = data.DataLoader(dataset,...)
# Model Definition
class Net(nn.Module):
 def __init__(self):
 super(Net, self).__init__()
 # ...
 def forward(self, x):
 # forward calculation ...
 return x
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# Training
for epoch in range(2):
 running_loss = 0.0
 for i, data in enumerate(trainloader, 0):
 # get the inputs
 inputs, labels = data
 # zero the parameter gradients
 optimizer.zero_grad()
 # forward + backward + optimize
 outputs = net(inputs)
 loss = criterion(outputs, labels)
 loss.backward()
 optimizer.step()
 # print statistics
 # ...
print('Finished Training')
# Validation
correct = 0
total = 0
with torch.no_grad():
 for data in testloader:
 images, labels = data
 outputs = net(images)
```

## [张量——自动微分的对象](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html)

对于基本数据结构——张量，~~不应该~~ 也可以用大写的 `torch.Tensor(data)` 来创建；官方推荐的方法是小写的 `torch.tensor(data)`，产生的张量是 `data` 的拷贝，对一方的改动不反映到另一方。

如果数据已经是 `numpy.ndarray` 了，可以用 `x_tensor = torch.from_numpy(x_array)` 和 `x_array = x_tensor.numpy()` 互相转化，他们使用同一片内存，对一方的改动会反映到另一方。

更推荐的方法是用各种工厂函数，比如 

- `torch.empty()`
- `torch.zeros()`, `torch.zeros_like()`
- `torch.ones()`, `torch.ones_like()`
- `torch.eye()`
- `torch.rand()`, `torch.rand_like()`

其中在声明随机张量之前使用 `torch.manual_seed(seed)`，可以让距离该函数相同执行距离的随机数代码总是产生相同的数值：

> [https://pytorch.org/docs/stable/notes/randomness.html](https://pytorch.org/docs/stable/notes/randomness.html)
> 

### 尺寸相关

张量的尺寸是一个它本身的一个性质 `x.shape`, 属于 `torch.Size` 类。

张量之间的计算，在尺寸不同时，遵循类似 NumPy 的 broadcasting 规则。

`x.item()` 从一个单元素张量（不一定是标量）里取出它的值，返回值的数据类型不再是 PyTorch 自己的类型，而是 python 原生类型。

`x.unsqueeze(dim)` 在第 dim 个维度增加一个长度为 1 的维度。

更一般的改变形状需要 `x.reshape(*new_shape)` 和 `torch.reshape(x,new_shape)`

### 物理设备相关

一般数学函数也有 `out` 参数，可以原位写入已存在的张量，不改变原张量的 id。

原位计算是在一般数学函数名字后面加一下划线，如 `torch.sin_(x)`, `x1.add_(x2)`

张量的赋值是传递指针，而不是传递数值。数值拷贝需要 `x2 = x1.clone()`. 克隆产物会保持和之前一样的 `requires_grad` 参数值。如果原张量在计算图里，新张量不需要的话应该 `c = a.detach().clone()`

参与运算的两个张量需要在同一设备 (CPU/GPU). 创建张量的时候可以用 `device` 参数声明设备，已经创建的张量可以用 `x.to(device)` 改变设备。

### 自动微分和神经网络相关

PyTorch 中的张量都有 `requires_grad` 参数，默认为 False。

对于带有 `requires_grad=True` 参数的张量，都受到自动微分机制 autograd 的控制。

前面每个每个创建张量的函数都接受这个参数，也自动传染给对自动微分的张量进行数学计算的结果。

神经网络，也就是继承自 `torch.nn.Module` 的对象（假设实例化为 `net`），内部有两个方法`net.parameters()` 和 `net.buffers()`，它们取到的是张量的 iterator，其中前者里面的张量（绝大多数）受 autograd 控制，后者不然。

要想取得某个神经网络的单个参数，需要知道 `__init__()` 方法中的变量名，以及官网文档中的参数名（一般在 Variables 小节，比如[这个例子](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html)）

```python
class MyNetwork(torch.nn.Module):
 def __init__(self):
 super().__init__()
 self.param1 = torch.nn.Parameter(torch.zeros((5,)),requires_grad=True)
 self.linear = torch.nn.Linear(in_features=5,out_features=1,bias=True)
 def forward(self,x):
 return self.linear(x * self.param1)
net = MyNetwork()
with torch.no_grad():
 print(net.param1)
 print(net.linear.weight)
 print(net.linear.bias)
```

## [自动微分](https://pytorch.org/tutorials/beginner/introyt/autogradyt_tutorial.html)

autograd 自动根据代码动态构建计算图：

```python
a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
b = torch.sin(a)
c = 2 * b
d = c + 1
out = d.sum()
```

![上述代码构成的计算图](/photos/2024-11-10-computation-graph.png)

对于数学函数 `b = f(a,*args)` 计算出来的张量 `b` ——

### `.grad_fn` 是一个函数

- 输入只有一个，尺寸需要和 `a` 的尺寸对齐 ~~（我感觉很奇怪）~~
- 输出的数量等于计算出这个张量的函数的输入的数量。
- ~~直接运行这个函数 ，基本就是把输入张量重复输出~~。从[这个问答](https://stackoverflow.com/questions/66402331/in-pytorch-what-exactly-does-the-grad-fn-attribute-store-and-how-is-it-used)来看，直接运行这个函数几乎没有意义，因为自动微分是用其他编程语言实现的，`SinBackward0` 并不是 Python 对象。
- `t.grad_fn.next_functions` 是一个 tuple，成员是 `x1` 等参数的 `.grad_fn`, 可以继续递推到工厂函数创建的张量，也就是这个计算图的叶节点。叶节点的 `.grad_fn` 为 `None`

```python
print(a.grad_fn) # None
print(b.grad_fn) # <SinBackward0 object at 0x000001C8E240F400>
print(c.grad_fn) # <MulBackward0 object at 0x000001C8E240EB30>
print(d.grad_fn) # <AddBackward0 object at 0x000001C8E240F400>
print(out.grad_fn) # <SumBackward0 object at 0x000001C8E240F190>
```

### `.backward()`

- 默认状态下，计算图的最终节点 `out` 是一个标量，也就是 0 阶张量。
 - 要想让计算图的最终节点是一个高阶张量，需要指定 `out.backward(gradient)` 参数。`gradient`和 `out` 尺寸相同，两者对应元素相乘后求和，从而成为一个标量。
 - 这种设定可以让一个张量的梯度 `.grad` 的尺寸只和自身的尺寸相等；如果允许计算从 `out` 到自身的 Jacobian 矩阵，会导致计算规模按多项式（一般是平方）增长。
- 默认状态下，一个计算图只能有一个`.backward()`，且只能执行一次。多次执行会报 `RuntimeError`: “Trying to backward through the graph a second time”。
 - 要想对完全相同的计算图做多次 `.backward()`, 需指定 `out.backward(retain_graph-True)` 参数。

### `t.grad`

- 偏导数张量 $$\partial\mathrm {out}/\partial \mathrm t$$，在最终节点运行 `.backward()` 之后，计算图中各节点的 `.grad` 会自动被 autograd 赋值
- 默认情况下，只有计算图的叶节点可以访问其 `.grad`
- 要取得中间节点的 `.grad`，需要在 `.backward()` 之前对相应张量执行 `.retain_grad()`

```python
b.retain_grad()
out.backward()

print(a.grad) # tensor([...],...), 约等于 2 * torch.cos(a)
print(b.grad) # tensor([2.,2.,2.,...2.],...)
print(c.grad) # None，不是计算图的叶节点，也没有 .retain_grad()
print(d.grad) # None，不是计算图的叶节点，也没有 .retain_grad()
print(out.grad) # None，不是计算图的叶节点，也没有 .retain_grad()
```

以上各个操作基本上符合数学的习惯。

## 张量及其微分的更新

以下设定更多的是为了工程上方便：

`.grad` 是一个张量的性质，不是最终节点和该张量两者之间的性质，也不是计算图整体的性质。

不论是 `.backward(retain_graph=True)`，还是另外构建了新的计算图并运行 `.backward()`（比如训练时加载了训练集的新一轮 batch），当一个已有 `.grad` 的张量被新的 `.backward()` 波及时，`.grad` 的新值会是旧值和本轮偏导数的相加。

如果不想要这种累加，需要主动提前将张量 `.grad` 改成 0 或者 None。

除了梯度张量的置 0，

### 手动

正常情况下，`requires_grad=True` 的张量，对其做的所有操作都会被 autograd 记录，包括赋值操作，这就导致正常情况下，不论是清空梯度，还是根据梯度更新模型的参数，会导致 auto grad 的混乱。

所以需要特殊操作，通知 autograd 某些对受控张量的改动，不需要成为计算图的一部分。

所谓的特殊操作就是 `torch.no_grad()`

```python
a = torch.arange(5.,requires_grad=True)
b = torch.sin(a)
b.backward(gradient=torch.ones_like(b))
with torch.no_grad():
 a[1] = 10
 a.grad.zero_() # a.grad = 0
print(a) # tensor([0,10,2,3,4], requires_grad=True)
```

在完全不涉及训练，只需要推理的环境，`with torch.inference():` 比 `with torch.no_grad():` 更节省计算资源。

### 自动

PyTorch 提供了上述操作的接口。

神经网络的参数的更新有一整个 `torch.optim` [模块](https://pytorch.org/docs/stable/optim.html#algorithms) 提供的更新参数的方式（`Optimizer` 的子类）。里面的优化器都实现了两个方法：`.step()` 和 `.zero_grad()`，前者修改参数本身的值，后者将各参数的梯度归零。

```python
class MyModel(torch.nn.Module):
 def __init__():
 # ...
 def forward(x):
 # ...
 return x
net = MyModel()
opt = torch.optim.SGD(net.parameters(),lr=0.01)
for e in range(epoch):
 # ...
 opt.step()
 opt.zero_grad()
```

如果只需要将梯度归零的话，nn.Module 也有一个 `.zero_grad()` 方法。

### `tensor` vs. `tensor.data`

看 SGD 优化器的源码的时候，看到更新权重的时候不是 `with torch.no_grad():`，而是用到了张量的 `a.data` 和 `a.grad.data`

`a` vs. `a.data`, `b.grad` vs. `b.grad.data` 的区别今天不需要知道，不应该知道。这是旧的 Variable 对象的残留，新的接口将 Variable 合并进了 Tensor，`.data` 只是为了兼容旧代码而存在的，不再推荐这种用法。

.ai | PyTorch 中的自动微分 autograd

## 一些名词

### 调试和测试

调试一般是由代码的作者进行，用于自行检查程序运行过程，是否存在思路和实现不匹配的错误，调试的代码一般和程序主体写在一起，主要包括错误处理和日志记录。简单的可以用 print 和 assert，复杂的程序可以用 logging。

测试一般由第三方进行，测试代码和程序代码分离，写测试的人甚至不需要理解程序的具体工作原理，只关注给定的输入能否得到程序宣称的输出。

### 单元测试

对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

检验的方法是写一堆测试用例，把测试员拍脑袋想的输入交给相应的模块，看模块的输出是否正确；以及不合理的输入是否被程序识别，抛出异常。

单元测试全通过了不代表程序整体一定就没错误，但是单元测试通不过的程序一定有问题。

### 文档测试

文档是对代码的功能介绍，其中不免要举例子，给出实例代码和相应的输出，这个过程很像是单元测试，只不过是纯嘴炮。

文档测试就是自动寻找文档中的示例代码，运行之后，和文档中的结果进行比对。

### 集成测试

集成测试模拟用户的行为，测试各个模块之间的配合，测试结果应该保证程序可以在生产环境中工作。

## Python 中的测试

### 文件结构

上一篇文章里面提到了 src-layout，在 setuptools 的官方文档里提供了[一篇博客文章](https://blog.ionelmc.ro/2014/05/25/python-packaging/#the-structure)，里面提到，这种文件结构的一个优点就是，测试代码的文件夹一般和 `src/` 而不是 package 平级，这就导致运行测试的时候只能先（在虚拟环境里）安装待测试的包，而不会无意中出现测试的代码和用户下载到的内容不同的问题。

```
<project_name>
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│ └── <package_name>/
│ ├── __init__.py
│ └── example.py
└── tests/
```

### 单元测试·`unittest`

`unittest` 是 Python 自带的单元测试库。

测试脚本的内容基本如下：

```
import unittest

class TestName1(unittest.TestCase):

 def test_sum(self):
 self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

 def test_sum_tuple(self):
 self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

class TestName2(unittest.TestCase):

 def test_sum(self):
 self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

 def test_sum_tuple(self):
 self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
 unittest.main()
```

- 测试用例包装在一个 class 里面，这个 class 继承自 `unittest.TestCase`
- 所有测试方法名字以 “test” 开头，能测试的性质有限，都是类自带的方法，以 `self.` 开头。支持的方法见下表，感觉 `[assertTrue(x)](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertTrue)` 和 `assertRaises(Exception)` 包打一切
- 作为 `'__main__'` 运行，运行的是自带的函数 `unittest.main()`。
- 运行时需要 python 指明脚本的文件名。安装了 nose2 这个库的话，可以直接运行 `python -m nose2`, 它会自动寻找所有的测试依次运行。（后面发现 `unittest` 好像也有自动发现功能）

| Method | Checks that | New in |
| --- | --- | --- |
| [unittest.TestCase.assertEqual](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertEqual) | a == b | |
| [unittest.TestCase.assertNotEqual](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotEqual) | a != b | |
| [unittest.TestCase.assertTrue](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertTrue) | bool(x) is True | |
| [unittest.TestCase.assertFalse](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertFalse) | bool(x) is False | |
| [unittest.TestCase.assertIs](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIs) | a is b | 3.1 |
| [unittest.TestCase.assertIsNot](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNot) | a is not b | 3.1 |
| [unittest.TestCase.assertIsNone](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNone) | x is None | 3.1 |
| [unittest.TestCase.assertIsNotNone](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNotNone) | x is not None | 3.1 |
| [unittest.TestCase.assertIn](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIn) | a in b | 3.1 |
| [unittest.TestCase.assertNotIn](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotIn) | a not in b | 3.1 |
| [unittest.TestCase.assertIsInstance](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsInstance) | isinstance(a, b) | 3.2 |
| [unittest.TestCase.assertNotIsInstance](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotIsInstance) | not isinstance(a, b) | 3.2 |

### 文档测试

[https://www.liaoxuefeng.com/wiki/1016959663602400/1017605739507840](https://www.liaoxuefeng.com/wiki/1016959663602400/1017605739507840)

Python 的文档测试用的是 `doctest` 库，写法如下：

```python
class Dict(dict):
 '''
 Simple dict but also support access as x.y style.

 >>> d1 = Dict()
 >>> d1['x'] = 100
 >>> d1.x
 100
 >>> d1.y = 200
 >>> d1['y']
 200
 >>> d2 = Dict(a=1, b=2, c='3')
 >>> d2.c
 '3'
 >>> d2['empty']
 Traceback (most recent call last):
 ...
 KeyError: 'empty'
 >>> d2.empty
 Traceback (most recent call last):
 ...
 AttributeError: 'Dict' object has no attribute 'empty'
 '''
 def __init__(self, **kw):
 super(Dict, self).__init__(**kw)

 def __getattr__(self, key):
 try:
 return self[key]
 except KeyError:
 raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

 def __setattr__(self, key, value):
 self[key] = value

if __name__=='__main__':
 import doctest
 doctest.testmod()
```

在保持 docstring 缩进的前提下，`>>>` 开头的注释会被当作测试运行，紧随其后的行将作为对比基准。只有当预期报错的时候，可以用 `...` 省略中间的报错信息。

### 集成测试

也可以用 `unittest` 完成。

和单元测试的区别在于，一般来说需要构建测试数据集等等。这需要重写 `unittest.TestCase.setup()`

```python
class TestComplexData(unittest.TestCase):
 def setUp(self):
 # load test data
 self.app = App(database='fixtures/test_complex.json')

 def test_customer_count(self):
 self.assertEqual(len(self.app.customers), 10000)

 def test_existence_of_customer(self):
 customer = self.app.get_customer(id=9999)
 self.assertEqual(customer.name, u"バナナ")
 self.assertEqual(customer.address, "10 Red Road, Akihabara, Tokyo")

if __name__ == '__main__':
 unittest.main()
```

.py | Python 测试笔记

> 这里所说的“别人”，也包括6个月之后，已经不记得当初如何写出这段代码的自己。
> 

很久以前写过一篇《**[import 引用现成的代码](https://mountaye.github.io/blog/articles/python-import-script-module-package)**》讲如何使用别人的代码，最后讲到一个模块的 `setup.py` 文件就没再往下写，这次继续。

- [https://packaging.python.org/en/latest/tutorials/packaging-projects/](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
- [https://setuptools.pypa.io/en/latest/userguide/quickstart.html](https://setuptools.pypa.io/en/latest/userguide/quickstart.html)

## 基本流程

- 写代码，且让代码项目文件的结构符合一定的要求（见下一节）
- 根据项目的文件结构，填写 `pyproject.toml`、`setup.cfg` **或** `setup.py` **文件**
- 安装 build 这个库，然后运行 `python -m build`，产生 `dist/` 文件夹及下面的文件。（可选）将项目上传到 PyPi 或者 Conda

## 项目文件结构

常用的文件结构有两种：src-layout 和 flat-layout，另外一些小项目只有一个 python 文件。

### src-layout

在 src-layout 里，写有 package 源代码的文件夹上层还套了一个文件夹，这个文件夹习惯上命名为 src，当然也可以是别的。`pyproject.toml` 和 `src/` 文件夹同级。

```
<project_name>
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│ └── <package_name>/
│ ├── __init__.py
│ └── example.py
└── tests/
```

### flat-layout

flat-layout 指的是写有 package 源代码的文件夹直接作为开发项目的第一级子文件夹，和 `pyproject.toml` 处于同一级。

这种结构比较古老，不太推荐

```
<project_name>
├── pyproject.toml # and/or setup.cfg/setup.py (depending on the configuration method)
├── <package_name>
| ├── __init__.py
| └── ... (other Python files)
├── test
| └── ... (test files)
├── # README.rst or README.md (a nice description of your package)
└── # LICENCE (properly chosen license information, e.g. MIT, BSD-3, GPL-3, MPL-2, etc...)
```

### 单文件项目

可以看作是 flat-layout 的一种特殊情况

```
<project_name>
├── pyproject.toml # and/or setup.cfg/setup.py (depending on the configuration method)
├── <my_module>.py
├── # README.rst or README.md (a nice description of your package)
└── # LICENCE (properly chosen license information, e.g. MIT, BSD-3, GPL-3, MPL-2, etc...)
```

## 填写 `pyproject.toml`、`setup.cfg` **或** `setup.py` **文件**

要想让构建程序把我们的代码打包成安装包，标题中的三个文件至少有一个要出现在 project 的根目录。

文件中要按照各自拓展名对应的语法，填写项目的有关信息，绝大多数可以顾名思义。

各参数的取值和代码文件结构相关，参数主要包括 `name`, `packages`, `package_dir`。如果文件结构完全满足上一节的结构，那么 `setuptools.find_packages()` 的[自动发现机制](https://setuptools.pypa.io/en/latest/userguide/package_discovery.html#automatic-discovery)就够用了。

### `name`

这是一个必填项。

注意：上一节的文件结构中，有两个名字 `<project_name>` 和 `<package_name>` ——

`<project_name>` 是整个开发项目的名字，如果用了类似 git 的版本控制的话，这个名字就是你的 repository 的名字。

`<package_name>` 比较复杂，它可以是，但不一定是你在其他代码中 `import __` 的名字，import 的名字由 `pyproject.toml` / `setup.cfg` **/** `setup.py` 里面的 `name` 参数指定。不能有连字符，只能用下划线。

如果你的 `name` 参数和 `<package_name>` 不同，还需要填写 `package_dir` 参数，

此外还有第三个名字，就是 `pip install __` 时候的名字，上传到 PyPI 的时候填写，可以带有连字符，比如 scikit-image。

### `packages`

参数是一个 list，但是一般都使用 `setuptools.find_packages()` 的结果。

该函数常用三个参数，都是可选的：

- `where`: 一个路径，相对于 `setup.py`
- `include`: 一个 list，元素是 glob patterns
- `exclude`: 一个 list，元素是 glob patterns

不指明任何参数 = 使用自动发现机制

### `package_dir`

参数是一个 dict，两种用法：

- 标准的 src-layout，直接写 `{"": "src/"}`, 表示所有的代码都在这个文件夹里。
- 当 python 模块的结构和代码的文件结构不同的时候，用这个 dict 指明 模块-文件夹 之间的关系。

文件的路径相对于 `setup.py` 而言

### `py_modules`

参数是一个文件路径的列表，几乎专为单文件结构而存在。

## 打包和上传

安装 build 工具：`python3 -m pip install --upgrade build`

运行 build：`python3 -m build`

如此会生成一个 `dist/` 文件夹，里面包含打包的结果。

要想让自己的程序可以被别人用 `pip install` 的方式安装，需要将打包成果上传到 PyPI，方法在[这里](https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-the-distribution-archives)。

## 安装

### 静态安装

已经上传到 PyPI 的包，可以直接用 `pip install <package>` 安装，这种方法叫做静态安装

### 动态安装

还在开发过程中的包，可以在 `setup.py` 所在的位置，运行 `pip install -e .` 这种安装方法叫做动态安装，因为代码的修改可以实时反映在引用的项目中。

## 思考题

上篇文章提到的一个[数据分析项目](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510)，其文件结构是这样的（我稍微改动了一下）：

```
/path/to/project/directory/
|-- notebooks/
 |-- 01-first-logical-notebook.ipynb
 |-- 02-second-logical-notebook.ipynb
 |-- prototype-notebook.ipynb
 |-- archive/
	 |-- no-longer-useful.ipynb
|-- src/
 |-- projectname/
	 |-- __init__.py
	 |-- config.py
	 |-- data.py
	 |-- utils.py
 |-- setup.py
|-- README.md
|-- data/
 |-- raw/
 |-- processed/
 |-- cleaned/
|-- scripts/
 |-- script1.py
 |-- script2.py
 |-- archive/
 |-- no-longer-useful.py
|-- environment.yml
```

问：

1. 这是一个 flat-layout 还是 src-layout？
2. setup.py 应该怎么写？执行动态安装时的 `pwd` 结果是什么？

.py | 让自己的代码可以被别人使用

在读 PyTorch 的文档和源码的时候，发现写文档的人也不怎么解释啥是卷积，卷积的各个参数是什么意思，只在文档里扔了个链接就完事了，链接那头是一个 GitHub 上的动图演示仓库，是一篇论文《A guide to convolution arithmetic for deep learning》（链接在文末）的附件。于是这篇文章，基本上就是论文的读书笔记了。

## 数学的卷积：连续 vs. 离散

### 定义

连续的情况，两个单变量函数 $$f(\cdot)$$ 和 $$g(\cdot)$$ 的卷积，定义为：

$$
\left(f*g\right)(x):=\int_{-\infty}^{\infty}f(\tau)g(x-\tau)d\tau
$$

离散的情况，两个向量（也就是一阶张量） $$\vec f$$ 和 $$\vec g$$ 的卷积，定义为：

$$
\left(\vec f * \vec g\right)_i := \sum_{j=-\infty}^{\infty} f_j g_{i-j}
$$

多变量函数/高阶张量的情况，只需要多加几重积分/求和号就可以类推了。

看这两个定义——

只看等号左边的话，可以把卷积看作是一种特殊的乘法，也就是一种**运算。**f 和 g 的地位是平等的，卷积甚至还满足交换律，你甚至可以把两者的顺序变一变；

但是看等号右边的话，卷积就应该被看作是一种**变换**。f 和 g 的地位不再平等，f 是被变换的函数/向量，g 是变换的核 (kernel)。函数的情况里，g 把定义在 $$\tau$$ 空间里的函数 f 变换成了 x 空间里的另一个函数；向量的情况里，g 把一个 J (j 所有可能取值的数量) 维向量 f 变换成了一个 I (i 所有可能取值的数量) 维向量。

神经网络中的卷积，**借用**的主要是第二种**理解**。

### 手算一个例子

例如 $$\vec f = (1,2,3,4)$$, $$\vec g = (1,2,3)$$，而且约定下标从 0 开始的话——

&nbsp; $$(\vec f*\vec g)_0 = f_0g_0 = 1$$

&nbsp; $$(\vec f*\vec g)_1 = f_0g_1 + f_1g_0 = 4$$

&nbsp; $$(\vec f*\vec g)_2 = f_0g_2 + f_1g_1 + f_2g_0 = 10$$

&nbsp; $$(\vec f*\vec g)_3 = f_1g_2 + f_2g_1 + f_3g_0 = 16$$

&nbsp; $$(\vec f*\vec g)_4 = f_2g_2 + f_3g_1 = 17$$

&nbsp; $$(\vec f*\vec g)_5 = f_3g_2 = 12$$

不想手算？

```python
import numpy as np
from scipy import signal
signal.convolve(np.array([1,2,3,4]),np.array([1,2,3]))
```

### 形象化表示

上面的计算过程，可以看作是——

1. 把 g 向量的**顺序反过来；**
2. 把 g 的最右一个元素和 f 的最左元素对齐，
3. 上下两行都有数字的列相乘（也就是把没有数字的地方看作 0），然后把所有乘积相加，得到 f*g 的第一项；
4. 把 g 向右移动一格
5. 重复第3、4步
6. 直到 g 的最左项移动到 f 的最右一个元素。

形如下列各表：

| --- | --- | --- | --- | --- | --- | --- |
| f | | | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 | | | |
| (f*g)(0) = 1 | | | 1 | | | |

<hr class="slender">

| --- | --- | --- | --- | --- | --- |
| f | | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 | | |
| (f*g)(1) = 4 | | 2 | 2 | | |

<hr class="slender">

| --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 | |
| (f*g)(2) = 10 | 3 | 4 | 3 | |

<hr class="slender">

| --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |
| g | | 3 | 2 | 1 |
| (f*g)(3) = 16 | | 6 | 6 | 4 |

<hr class="slender">

| --- | --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 | |
| g | | | 3 | 2 | 1 |
| (f*g)(4) = 17 | | | 9 | 8 | |

<hr class="slender">

| --- | --- | --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 | | |
| g | | | | 3 | 2 | 1 |
| (f*g)(5) = 12 | | | | 12 | | |

## 机器学习的卷积，是卷积吗？

看论文给出的图 Figure 1.1，在卷积核是灰色 3\*3 矩阵的情况下，对蓝色 5\*5 矩阵的卷积就是直接把核对齐到蓝色矩阵上，**并没有把核的元素顺序颠倒过来**。

这玩意能叫卷积吗？

![convolution](/photos/2022-12-29-convolution.png)

有人强行挽尊，说我们画图示的时候已经把核给颠倒过来了，想知道卷积核就把灰色小矩阵再颠倒回去——

但是，不颠倒就对齐相乘的运算也是有名字的，叫 cross correlation。核有没有颠倒，convolution 还是 cross correlation 一组合，可以带来升维打击般的混乱，堪比高中化学的“还原剂被氧化，氧化剂被还原”……所以，对于计算机专业的数学水平，不予置评～


## 卷积`torch.nn.Conv` 及其各个参数

### `in_channels` & `out_channels`

“卷积”的意义在于用一种比较省内存的方式，考虑输入张量中各个元素，和空间上相近的邻居元素之间的关系。所以只需要在真的存在空间关系的维度做卷积，其他维度可以留着不动。

比如一张彩色图片，是一个 (颜色*高度*宽度) 的 3 阶张量，我们只需要对高度和宽度两个维度做卷积，颜色就是不参与“卷积”的 channel。

`in_channel` 就是被“卷积”的张量的 channel 数，`out_channel` 是“卷积”结果的 channel 数。比如我们想从一张 RGB 三色图片中分辨出前景和背景两种不同区域，`in_channel=3`, `out_channel=2`。

而 `in_channel` 如何能够与 `out_channel` 取值不同，原理见 Figure 1.3。我们使用 `out_channel` 个不含 channel 维度的“卷积”核，每一个核都与每一个 in channel 做卷积，得到图中的蓝、紫色小矩阵，然后直接把不同的 in channel 暴力求和，得到的结果分别作为卷积结果的 out channel。（这个暴力求和与我以前想得不一样，我以为是什么每一元素都做了一个`in_channel`*`out_channel` 的全联通层）

![channels](/photos/2022-12-29-channels.png)

 PyTorch 的习惯，对于一个 N 阶“卷积”，参与卷积的是张量的最后 N 阶，`in_channel` 和 `out_channel` 也就是被卷张量和卷积结果的 `Tensor.shape[-(N+1)]`

后面图示的例子都没有考虑 `in_channel` 和 `out_channel` 的数量，也就是都当作 1 了。

### `kernel_size`

就是灰色矩阵“卷积”核，每边有几个数字。如果不同方向的边长不一，该参数就需要用一个 tuple 来表示。Figure 1.1 的灰色卷积核，`kernel_size=(3,3)`

![kernel](/photos/2022-12-29-kernel.png)

### `padding` & `padding_mode`

前面手算例子的时候很鸡贼地把 0 作为向量下标的起点。如果采用日常 1 开头的下标来算，第 1 项结果为零，整个卷积结果的长度会长很多，而且多出来的后面几项也都是零。

而且在这个过程中，我们实际上是把一个有限长度的向量，看作了一个以所有整数 $$\Z$$ 为定义域的函数，除了那有限的几项之外，其余地方都定义函数值为 0。

用计算机计算的话显然没法如此奢侈地谈“无限多个”，例子中实际用到的，在 $$\vec f$$ 左右两边各需要 2 个 0，也就是说 `padding=2`, `padding_mode='zeros'`

Figure 1.2 表示的就是 `padding=(1,1)` 的情况（蓝色是被卷张量，白色是 padding，灰色是卷积核，绿色是卷积结果）：

![padding](/photos/2022-12-29-padding.png)

既然神经网络中的卷积并不是真正的卷积，所以他们索性不装了——

正常卷积的结果往往比被卷张量大一圈（具体大多少取决于 `kernel_size`, `padding`, `stride` 多个参数），但是图像处理的时候经常希望输出图片和输入图片一样大，此时可以用字符串 `“same”` 作为 `padding` 的参数，自动计算 padding 的大小。`“strict”` 则表示 `padding=0`, 这样输出图片尺寸会变小，但是没有 padding，也就没有往图片里掺杂研究者对图片边缘以外信息的臆测。

同时 `padding_mode` 参数表示往被卷张量四周填充的数字也不一定是 0。比如对于图片，0 往往表示纯黑，而绝大多数图片的视野之外，往往是和图片边缘像素值相差不大的值。所以 `padding_mode` 除了 `zeros` 之外，还接受以下取值：

- `reflect`: 以图片边缘为镜面，把边缘附近的像素值对陈反射出去；
- `replicate`: 只取边缘的像素值作为常数，直接向外延拓；
- `circular`: 类似于物理中的周期性边界条件，取对边附近的像素值作为 padding 内容。

### `stride`

前面手算卷积的第4步，把卷积核向右移动了1格，如果每次移动超过1格，就需要这个参数指定移动步长。如果不同方向的步长不同，也是用 tuple 来表示。

Figure 1.4 表示的就是 `stride=(2,2)` 的情况（蓝色是被卷张量，蓝色中的深色块是卷积核，绿色是卷积结果）：

![stride](/photos/2022-12-29-stride.png)

### `dilation`

这个参数把“卷积”核撑开，也就相当于在“卷积”核的相邻元素之间加 0。Figure 1.5 表示的就是 `dilation=(1,1)` 的情况（蓝色是被卷张量，蓝色中的深色块是卷积核，绿色是卷积结果）：

![dilation](/photos/2022-12-29-dilation.png)

比如 `dilation=1` 时，(1,2,3) 的卷积核就相当于 (1,0,2,0,3)

比如 `dilation=2` 时，(1,2,3) 的卷积核就相当于 (1,0,0,2,0,0,3)

这样可以让卷积核在尺寸比较小的情况下，覆盖到更大面积的被卷张量。当然具体实现时，不可能直接补 0 这么浪费内存。

### `groups`

该参数必须是 `in_channel` 和 `out_channel` 的公约数，当其不为 1 时，就相当于同时做 `groups` 个卷积，其中每个卷积的 `in_channel=in_channel/groups`, `out_channel=out_channel/groups`

### `bias`

该参数是一个布尔值，卷积类似于一种高维空间里的乘法，这个参数就决定是否要拟合 `y=kx+b` 中的 `b`

## “卷积”的“逆运算”： `TransposeConv`

卷积的结果比 padding 之后的被卷张量要小。尤其当“卷积”的 `stride` 约等于 `kernel_size` 时，卷积的就变成了某些池化 (pooling)（求最大值不是一种线性算子，所以最大值池化不能用卷积表示，但是平均值池化可以）。

那么在类似 U-net 这样的模型里，右半边的数据升维（下图中的绿箭头），就需要一种“卷积”的“逆运算”。有人把这种运算叫做 deconvolution，有人叫做 transposed convolution，还有人叫做 convolution with fractional strides。

![Unet](/photos/2022-12-29-unet.png)

PyTorch 取的是第二种名字。论文解释了为什么这么取名字，笔记以后有时间再补上把……

因为这个与运算本身就是作为“卷积”的逆运算出现的，所以 PyTorch 的文档里这么说：

> This is set so that when a `Conv2d` and a `ConvTranspose2d` are initialized with same parameters, they are inverses of each other in regard to the input and output shapes.
> 

也就是说，把 `ConvTranspose` 的输入和输出反过来，然后按照 `Conv` 的规则确定各个参数，填入 `ConvTranspose` 的括号里就可以了，除了 `output_padding`

### `output_padding`

`ConvTranspose` 的输出就是对应 `Conv` 的输入。看 Figure 2.7：

![padding_output](/photos/2022-12-29-output-padding.png)

当 $$(input+2*padding)/stride$$ 不能整除的时候，最右的几列最下的几行就被卷积核忽略掉了。那么在逆运算 `TransposeConv` 中，这就意味着同一个输入可能对应着 $$stride-1$$ 种可能的输出。`output_padding`参数就可以消除这种歧义，调整 `TransposeConv` 输出张量的尺寸。

## 参考链接

- 给卷积正名: [https://www.kaggle.com/general/225375](https://www.kaggle.com/general/225375)
- PyTorch Conv2d 源码: [https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#_ConvNd](https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#_ConvNd)
- 论文: [https://arxiv.org/abs/1603.07285](https://arxiv.org/abs/1603.07285)
- 动图演示: [https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md](https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md)
- U-net: [https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/)
- PyTorch TransposeConv 文档: [https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html](https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html)

.ai | 神经网络中的卷积及其参数


最近参加了一个关于如何在 Python 项目中利用 GPU 提高运算效率的培训，里面提到了 `numba` 这个加速科学计算的库，而 `numba` 发挥作用的主要工具就是各种装饰器。

所谓装饰器，就是读一些网上现成的 python 代码的时候会看到的，函数前一行 `@` 打头的一串字符，一般是一个名字，偶尔会附带有参数：

```python
@decorator
def myfunction():
    # do something...
    return results
```

它的实际作用相当于：

```python
def myfunction():
    # do something...
    return None

myfunction = decorator(myfunction)
```

Python 是一种[函数式编程语言](https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html)，函数和各种类型的变量一样，在 Python 都是一种对象，所以可以把函数赋值给一个变量，可以在函数里定义另一个函数，可以把函数作为参数传递给另一个函数，可以把函数名作为另一个函数的返回值。

`myfunction = decorator(myfunction)` 就是装饰器的定义，是 Python 的一个[语法糖](https://zh.m.wikipedia.org/zh-hans/%E8%AF%AD%E6%B3%95%E7%B3%96)。也就是说装饰器本身也是一个函数，我们的函数被装饰器装饰之后，函数名称不变，在完整实现函数原有功能的同时，额外执行装饰器中的命令。

### 装饰器是如何做到的

要想自己写一个装饰器的话，需要了解一下装饰器的实现原理。一个最简单的装饰器可以这么写：

```python
def decorator(func):
    def inner():
        # do something
        func()
        # do some more
        return None
    return inner
```

也就是在装饰器内部再定义一个函数，这个内部函数的函数体执行被装饰的函数，然后外层装饰器把内层函数名当作返回值。

### 如果一个函数需要多个装饰器

把前面装饰器的定义套在多个装饰器的情况里：

```python
@decorator1
@decorator2
def myfunction():
    return None

myfunction = decorator1(decorator2(myfunction))
```

### 如果被装饰的函数有传入参数

装饰器不知道自己要装饰的函数长什么样，也就不知道函数接受多少个参数，其中有几个是位置参数，几个是关键词参数。所以需要用单星号打包/解包位置参数，双星号打包/解包关键词参数。`args` 和 `kwargs` 是变量名的代词，可以换成其他自己喜欢的名字。

```python
def decorator(func):
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return None
    return inner

@decorator
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return None
```

### 如果被装饰的函数有返回值

则装饰器的内层函数需要把被装饰的函数的返回值返回出来：

```python
def decorator(func):
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return func(*args,**kwargs)
    return inner

@decorator
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return results
```

### 如果想让装饰器本身接受参数

也就是想达到下面的效果：

```python
@param_decorator(param="neat")
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return results
```

也就是让 `param_decorator(param="neat")` 返回一个装饰器函数，也就是在之前的装饰器外面再加一层：

```python
def param_decorator(param):
    def decorator(func):
        def inner(*args,**kwargs):
            if param=="neat":
                print("neat")
                # ...
            else:
                print("not neat")
                # ...
            func(*args,**kwargs)
            return func(*args,**kwargs)
        return inner
    return previous_decorator
```

### 如果想让装饰器既可以接受参数，也可以不接受参数～

实在是有点过于高级了，直接说答案：

```python
def flex_decorator(_func=None,*,kw1="val1",kw2="val2"):
    def decorator(func):
        def inner(*args,**kwargs):
            print(kw1,kw2)
            # do something
            func(*args,**kwargs)
            # something else
            return func(*args,**kwargs)
        return inner
    if _func is None:
        return decorator
    else:
        return decorator(_func)
```

根据 [https://peps.python.org/pep-3102/](https://peps.python.org/pep-3102/)，`*`作为一个单独的函数参数，表示后面所有的参数都是关键词参数，用来限定星号前面位置参数的数量。

- 当 `@flex_decorator` 不加参数使用的时候:
    - 根据定义 `myfunction = flex_decorator(myfunction)`
    - `_func=myfunction`
    - 此时 `else` 生效，`myfunction = decorator(myfunction)`
- 当 `@flex_decorator(kw1="val1",kw2="val2")` 加上参数使用的时候:
    - 根据定义 `myfunction = flex_decorator(kw1="val1",kw2="val2")(myfunction)`
    - `_func=None`
    - 此时 `if` 生效，`myfunction = decorator(myfunction)`

——**接受的参数必须是关键词参数**，否则和被装饰的函数名无法区分。

### `@functools.wraps`：刻章、办证

以上各节基本完成了常用场景下装饰器的功能。

但是，Python 作为一种动态语言，一大特征就是可以在运行时进行[类型内省](https://en.wikipedia.org/wiki/Type_introspection)。而按照我们上面的写法，被装饰之后的函数，Python 认为它不再是原来的函数，而是装饰器里面定义的那个内部函数，这样可能会出现意想不到的问题。

解决方法是使用一个专门的装饰器根装饰器定义的内部函数办个假身份：

```python
import functools

def decorator(func):
    @functools.wraps(func)
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return func(*args,**kwargs)
    return inner
```


.py | Python decorator 装饰器


## 一般监督学习的数据结构和处理过程

### 训练集、验证集、测试集

所有数据整体构成一个大集合，这个集合的每一个元素都包含一个输入和一个目标，分别记作 x 和 y。

把这个大集合分成互相没有交集的三个子集，分别是训练集 (training set)、验证集 (validation set)、测试集 (test set)。

- 训练集和验证集在训练过程中使用。
    - 训练集的数据带入模型时，模型处于训练模式，模型输出对参数的导数被记录。通过比较把“模型输出”和“训练目标 y”代入**损失函数**的损失，更新模型的参数。同时记录“模型输出”和“训练目标 y”带入验证函数的结果，和验证集比较。
    - 验证集的数据代入模型时，模型处于求值模式，模型只根据输入计算输出，对参数的导数不记录。通过观察“模型输出”和“训练目标 y”带入**验证函数**的结果，观察训练是否陷入“过拟合”。当训练集的验证函数结果不断下降，但是验证集的验证函数结果几乎不变时，可以认为模型过拟合。
- 测试集在训练完成之后使用，代入模型时，模型处于求值模式。用于评价训练结果的好坏。

### epoch vs. batch

如果把所有数据同时进行训练，所需要的空间一般都大于电脑内存。所以一般会将训练集随机分成若干批次 (batch)，一个批次的数据同时塞入模型进行训练，在一个 batch 里每一个模型输出对参数的导数累加在一起，整个 batch 结束后更新模型参数，同时导数清零。因为 batch 这个概念和内存有关，所以数值一般选择为 2 的指数。

将训练集所有的 batches 跑完一次称为而一个 epoch。一次训练一般需要很多 epochs，直到损失函数结果足够低，或验证集显示出现过拟合。

## PyTorch 对上述结构和处理过程的封装

### `Dataset`

前面已经说了，数据集包括输入和目标两部分，`Dateset` 及其子类的作用就是

如果在把数据装入 `Dataset` 之前就已经是规整的两个张量了的话——

```python
import torch
from torch.utils import data

# ...

for x,y in zip(train_x,train_y):
    # do something with x and y

trainset = TensorDataset(train_x,train_y)
for x,y in trainset:
    # do something with x and y
```

——这一步确实没什么意思。

有意思的地方在于可以自己写一个数据集类，继承 `Dataset`，然后重载 `__getitem__()` 和 `__len__()` 方法，这样可以把一些不适合用张量表示的数据塞进 `Dataset` 里面，对图像进行学习的话可以在此处加入图像增强的步骤，并进一步用于 `DataLoader`

### `DataLoader`

`DataLoader` = `Dataset` + `Sampler`，因为一般的教程里只需要讲数据集进行简单随机划分，也就只用到了 `batch_size` 等等参数，用到 Sampler 的地方很少。

最常见的用例就是 `WeightedRandomSampler` 。训练分类器的时候，有时其中一个类别的数据远少于其他，那么训练器就更难判断出这一分类（因为只要无脑排除这个类别就能获得不错的正确率），所以需要平衡不同组别之间的权重。

```python
list(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True))
# [4, 4, 1, 4, 5]
list(WeightedRandomSampler(weights=[0.9, 0.4, 0.5, 0.2, 0.3, 0.1], num_samples=5, replacement=False))
# [0, 1, 4, 3, 2]
```

平衡完之后转化为 batch，搭配 `BatchSampler`：

```python
list(BatchSampler(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True), batch_size=2, drop_last=False))
# [[4, 4], [1, 4], 5]
list(BatchSampler(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True), batch_size=2, drop_last=True))
# [[0, 1], [4, 3]]
```

### 汇总一下

```python
import torch
from torch.utils import data

train_x = torch.rand((100,5))
train_y = torch.rand((100,2))
trainset = data.TensorDataset(train_x,train_y)

# either:
trainloader = data.DataLoader(
    trainset,
    batch_size=2,
    drop_last=True,
    sampler=data.WeightedRandomSampler(
        weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], 
        num_samples=5, 
        replacement=True))
# or:
trainloader = data.DataLoader(
    trainset,
    batch_sampler=data.BatchSampler(
        data.WeightedRandomSampler(
            weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], 
            num_samples=5, 
            replacement=True), 
        batch_size=2, 
        drop_last=True))

for epoch in range(100):
    for x,y in trainloader:
        train(model,x,y,loss_function)
```

需要注意的是，`for x,y in trainset` 的 x 和 y 的维度是单个数据的维度，最简单的情况就是是 P 和 Q 维向量，而此时如果把 batch_size 记作 B，`for x,y in trainloader` 中的 x 和 y 是维度分别为 (B,P) 和 (B,Q) 的矩阵。`train()` 函数里面的计算要考虑到多出的这一个维度。

## 参考链接：

- [https://pytorch.org/tutorials/beginner/basics/data_tutorial.html](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html)
- [https://pytorch.org/tutorials/beginner/nn_tutorial.html](https://pytorch.org/tutorials/beginner/nn_tutorial.html)
- [https://pytorch.org/tutorials/beginner/ptcheat.html](https://pytorch.org/tutorials/beginner/ptcheat.html)
- [https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset)
- [https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)
- [https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.Sampler](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.Sampler)
- [https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#Dataset](https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#Dataset)


.py | PyTorch 数据处理方面的封装


- 电脑设置、python 入门
    - NoMachine, ssh, python, conda, jupyter
    - 文件夹操作 `pathlib`, 图片操作 `skimage`
    - 数据增强 (data augmentation): `imgaug`
    - TensorBoard
- 机器学习简介
    - Linear Classifier
    - `sklearn**.**model_selection**.**train_test_split()`
    - Stochastic gradient descent
    - TensorFlow:
        - `tensorflow_addons as tfa`
        - `tfa.image.rotate()`, `tf.image.random_flip_left_right()`
        - **`from** tensorflow.keras **import** Model`, **`from** tensorflow.keras.models **import** Sequential`, **`from** tensorflow.keras.layers **import** Input, Flatten, Dense, Activation, BatchNormalization, Conv2D, MaxPool2D, Softmax`
        - `tf**.**keras**.**losses**.**CategoricalCrossentropy()`, `tf**.**keras**.**optimizers**.**Adam(lr**=**1e-3, clipnorm**=**0.001)`
        - `linear_classifier **=**``Model(...)`, `linear_classifier.compile()`, `linear_classifier.fit()`, `linear_classifier.predict()`
- 深度学习简介
    - Perceptron
    - Perceptron-based XOR gate
    - **decision boundary** of your model: `np.meshgrid`
- 图像恢复 (image restoration)
    - CARE network
    - Noise2Nosie, Noise2Void
- 图像翻译 (image translation)
    - micro-DL: a tool to generate and train U-net from config files.
- 图像语义分割 (image semantic segmentation): 比较详细，前两节有点水了。
    - **`from** PIL **import** Image`, **`import** imageio`, **`from** torchvision **import** transforms`
    - **`from** torch.utils.data **import** Dataset, DataLoader`, **`import** torch.nn **as** nn`, **`from** torch.nn **import** functional **as** F`,  **`from** torch.utils.tensorboard **import** SummaryWriter`,
    - U-net on PyTorch
- 图像实例分割 (instance segmentation)
    1. Foreground segmentation: 
        - **Receptive Field of View**: The term is borrowed from biology where it describes the "portion of sensory space that can elicit neuronal responses when stimulated" (wikipedia). Each output pixel can look at/depends on an input patch with that diameter centered at its position. Based on this patch, the network has to be able to make a decision about the prediction for the respective pixel.
        - **Early Stopping** to avoid overfitting: define an `EarlyStopping` class
    2. Instance Segmentation:
        - Ideas:
            - Three-class model (foreground, background, boundary),
            - Distance transform (label for each pixel is the distance to the closest boundary),
            - Edge affinity (consider not just the pixel but also its direct neighbors, predicts the probability that there is an edge, this is called affinity.) 听的时候懂了，回来看的时候没太看懂
            - Metric learning (learns to predict an embedding vector for each pixel.)
    3. **Tile and Stitch：**
        - 当需要处理的图片过大时，将图片切分成多个小图，分别预测之后拼接在一起。
        - 文中说图片尺寸不是 某个参数的整数倍的时候拼贴结果会不连续，但是代码注释中说等于这个整数倍的时候会不连续，晕。
        - [https://arxiv.org/pdf/2101.05846.pdf](https://arxiv.org/pdf/2101.05846.pdf)
    4. 一个实例，epithelia cells
- 失败模式：极其之水，就是科普了一下训练参数错误的后果，以及一点对抗学习的内容
- 追踪：比较水，因为机器学习追踪的运算量极大，且主讲人感觉就是来做广告的，所以就直接用 CoLab 体验了一下就完事了。（就这还加州理工呢~）
- 知识提取：
    - 前面的基本上是从像素到像素的映射，这里的知识提取是从图片到标签的映射。
    - CycleGAN
    - **Create a balanced Dataloader**
    

.py | 深度学习暑期学校知识点


自学，或者说一切学习和教学，本质就是在已经掌握的知识和未知的目标知识之间修路。路有两种修法，一是理论或者说是第一性原理路线，从不证自明的公理或者已经掌握的知识出发，通过逻辑推理一步步得到新的知识；另一种是实践或者说工程师路线，拿到一个已经可以工作的产品，划分成各个子系统，通过输入的改变来观察输出的不同，直到子系统简化到自己可以理解的地步，不再是黑箱，借此了解整个系统的功能。

但是当学习的对象复杂到一定程度之后，凭借一个人的自学能力，只用其中一种方法往往难以钻透。又或者两种方法学到的路线并非同一条路。对于机器学习，理论路线就是“让输入数据通过一个带有超多参数的函数，根据函数返回值和输出数据之间的差别修正参数，直到函数能够近似输入数据和输出数据之间的关系”；实践中代码往往会使用很多库作者封装好的函数，只读源码往往一头雾水。

所以，看到 PyTorch 官网的这篇教程 **WHAT IS TORCH.NN *REALLY*?:** [https://pytorch.org/tutorials/beginner/nn_tutorial.html](https://pytorch.org/tutorials/beginner/nn_tutorial.html) 可以说是喜出望外，把两种路线写出的代码都给了出来，对于自学者来说，就像罗塞塔石碑一样可以互相对照。这里我把 CNN 相关的部分抽掉了，毕竟 CNN 只是深度学习的一个子集，深度学习只是机器学习的一个子集，和这篇文章的主题关系不大。

原文先按照第一性原理，尽量用原生 python 写了一遍，然后一步一步重构成接近生产环境的代码。这里我把顺序反过来，先放出重构之后的最终结果：

```python
from pathlib import Path
import requests
import pickle
import gzip
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from torch import optim
from torch.utils.data import TensorDataset,DataLoader

# Using GPU

print(torch.cuda.is_available())
dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

# Wrapping DataLoader
# https://pytorch.org/tutorials/beginner/basics/data_tutorial.html?highlight=dataloader
# https://pytorch.org/tutorials/beginner/data_loading_tutorial.html?highlight=dataloader

def preprocess(x, y):
    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )

class WrappedDataLoader:
    def __init__(self, dl, func):
        self.dl = dl
        self.func = func

    def __len__(self):
        return len(self.dl)

    def __iter__(self):
        batches = iter(self.dl)
        for b in batches:
            yield (self.func(*b))

# Define the neural network model to be trained

# # If the model is simple:
# model = nn.Sequential(nn.Linear(784, 10))

# generally the model is a class that inherites nn.Module and implements forward()
class Mnist_Logistic(nn.Module):
    def __init__(self):
        super().__init__()
        # self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))
        # self.bias = nn.Parameter(torch.zeros(10))
        self.lin = nn.Linear(784, 10)

    def forward(self, xb):
        # return xb @ self.weights + self.bias
        return self.lin(xb)

# Define the training pipeline in fit()

def loss_batch(model, loss_func, xb, yb, opt=None):
    loss = loss_func(model(xb), yb)

    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()

    return loss.item(), len(xb)

def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)

        model.eval()
        with torch.no_grad():
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)

        print(epoch, val_loss)
    return None

# __main()__:

# data
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)

train_dataset = TensorDataset(x_train, y_train)
valid_dataset = TensorDataset(x_valid, y_valid)
train_dataloader, valid_dataloader = get_data(train_ds, valid_ds, bs)
train_dataloader = WrappedDataLoader(train_dataloader, preprocess)
valid_dataloader = WrappedDataLoader(valid_dataloader, preprocess)

# hyperparameters/model
learning_rate = 0.1
epochs = 2
loss_function = F.cross_entropy # loss function
model = Mnist_CNN()
model.to(dev)
optimizer = optim.SGD(model.parameters(), lr=learning_rate , momentum=0.9)

# training
fit(epochs, model, loss_function, optimizer, train_dataloader, valid_dataloader)
```

可以看到，一个项目主干可以分成4部分：

1. 准备数据
2. 定义模型
3. 描述流程
4. 实际运行

下面把各部分拆分开来，把两种思路的代码进行对比。

## 1. 准备数据

### 重构之前

```python
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)
n, c = x_train.shape
```

### 重构以后：

```python
# Wrapping DataLoader
# https://pytorch.org/tutorials/beginner/basics/data_tutorial.html?highlight=dataloader
# https://pytorch.org/tutorials/beginner/data_loading_tutorial.html?highlight=dataloader

def preprocess(x, y):
    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )

class WrappedDataLoader:
    def __init__(self, dl, func):
        self.dl = dl
        self.func = func

    def __len__(self):
        return len(self.dl)

    def __iter__(self):
        batches = iter(self.dl)
        for b in batches:
            yield (self.func(*b))
```

## 2. 定义模型

### 重构之前

```python
weights = torch.randn(784, 10) / math.sqrt(784)
weights.requires_grad_()
bias = torch.zeros(10, requires_grad=True)

def log_softmax(x):
    return x - x.exp().sum(-1).log().unsqueeze(-1)

def model(xb):
    return log_softmax(xb @ weights + bias)

def nll(input, target):
    return -input[range(target.shape[0]), target].mean()
loss_func = nll

def accuracy(out, yb):
    preds = torch.argmax(out, dim=1)
    return (preds == yb).float().mean()
```

### 重构以后

```python
# If the model is simple:
model = nn.Sequential(nn.Linear(784, 10))

# generally the model is a class that inherites nn.Module and implements forward()
class Mnist_Logistic(nn.Module):
    def __init__(self):
        super().__init__()
        # self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))
        # self.bias = nn.Parameter(torch.zeros(10))
        self.lin = nn.Linear(784, 10)

    def forward(self, xb):
        # return xb @ self.weights + self.bias
        return self.lin(xb)

```

## 3. 描述流程

### 重构之前

```python
lr = 0.5  # learning rate
epochs = 2  # how many epochs to train for

for epoch in range(epochs):
    for i in range((n - 1) // bs + 1):
        #         set_trace()
        start_i = i * bs
        end_i = start_i + bs
        xb = x_train[start_i:end_i]
        yb = y_train[start_i:end_i]
        pred = model(xb)
        loss = loss_func(pred, yb)

        loss.backward()
        with torch.no_grad():
            weights -= weights.grad * lr
            bias -= bias.grad * lr
            weights.grad.zero_()
            bias.grad.zero_()
```

### 重构以后

```python

def loss_batch(model, loss_func, xb, yb, opt=None):
    loss = loss_func(model(xb), yb)

    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()

    return loss.item(), len(xb)

def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)

        model.eval()
        with torch.no_grad():
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)

        print(epoch, val_loss)
    return None
```

## 4. 实际运行

### 重构之前

```python
# __main()__:
print(loss_func(model(xb), yb), accuracy(model(xb), yb))
```

### 重构以后

```python
# __main()__:

# data
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)

train_dataset = TensorDataset(x_train, y_train)
valid_dataset = TensorDataset(x_valid, y_valid)
train_dataloader, valid_dataloader = get_data(train_ds, valid_ds, bs)
train_dataloader = WrappedDataLoader(train_dataloader, preprocess)
valid_dataloader = WrappedDataLoader(valid_dataloader, preprocess)

# hyperparameters/model
learning_rate = 0.1
epochs = 2
loss_function = F.cross_entropy # loss function
model = Mnist_CNN()
model.to(dev)
optimizer = optim.SGD(model.parameters(), lr=learning_rate , momentum=0.9)

# training
fit(epochs, model, loss_function, optimizer, train_dataloader, valid_dataloader)
```

.py | 一个 PyTorch 机器学习项目长什么样


笔记本的触摸屏被我摔了道裂纹，一开始还不影响使用，但是最近几周情况恶化，有时鼠标光标会突然暴走，不听指挥。所以需要禁用触摸屏作为输入设备。

在 xorg 的桌面环境之下，可以用 `xinput list` 显示出所有输入设备，以及对应的 id 号码。然后把找到的 id 填入 `xinput disable ##` 就可以了。一般来说这个 id 的数值是稳定的，所以我就直接把禁用命令写到 `~/.bashrc` 里面去了。

然而，最近把吃灰很久的树莓派拿出来玩了，所以败家买了个60%布局的小机械键盘，小键盘往笔记本一插，诶，您猜怎么着，新买的键盘输完密码登陆之后就不能用了，着实吓了一跳。

所以需要每次检查一遍输入设备的 id，然后把和触摸屏有关的 id（不止一个）从 `xinput list` 的输出里摘出来赋值给一个变量，然后把变量带入 `xinput disable #` 里面。这一套操作已经超出我的 bash 能力了，所以考虑用 python 完成中间步骤，也就是需要让 python 读 bash 的命令结果，写 bash 的命令语句。

Googles搜索给到了这个结果：[https://stackoverflow.com/questions/4256107/running-bash-commands-in-python](https://stackoverflow.com/questions/4256107/running-bash-commands-in-python)，稍微看了一下 subprocess 的官方文档，写了下面的一段，存到 `~/disable_touchscreen.py`, 然后在 `~/.bashrc` 里加一句 `python ~/disable_touchscreen.py`

```python
import subprocess
check = subprcess.run(["xinput","list"],capture_output=True)
for line in check.stdout.decode("utf-8").split("\n"):
    if "touchscreen" in line:
        device = line.partition("id=")[2].partition("\t")[0]
        disable = subprocess.run(["xinput","disable",str(device)])
        if disable.returncode==0:
            print(f"Successfully disabled touchscreen device {device}")
        else:
            print(f"Failed to disable touchscreen device {device}")
```

- 这段代码的核心是 `subprocess.run()` ，第一个参数就是传给 bash 的命令，这是一个list，其中每个元素就是 bash 语句用空格分割开的每一部分。要想得到命令的执行结果，需要添加参数 `capture_output=True`
- 上面函数的返回值是一个特殊的数据结构，命令顺利执行的话，结果会写在 `.stdout` 里，这是一个二进制串 `b'xxx...'`，所以需要 `.decode("utf-8")` 转化成字符串。

如果只用bash的话，

- 我的 bash 水平可以做到 `xinput list | grep "touchscreen"`, 这里的 `|` 是一个管道，也就是将前一条命令的输出传递给后一条作为输入。要想在 python 里使用管道，可以看这个问答：[https://stackoverflow.com/questions/13332268/how-to-use-subprocess-command-with-pipes](https://stackoverflow.com/questions/13332268/how-to-use-subprocess-command-with-pipes)
- 上面管道的结果还需要裁剪出 id 号，也就是 `line.partition("id=")[2].partition("\t")[0]`，估计需要用到 awk, 虽然难，但可以学，至少知道该学什么；
- 但是把 id 号传递给一个变量，然后把这个变量填进 `xinput disable`, 这一步就连该学什么也不知道了。


.py | python.subprocess执行bash命令


- 官网教程：[https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html)
- 官方文档：[https://pytorch.org/docs/stable/tensorboard.html](https://pytorch.org/docs/stable/tensorboard.html)

TensorBoard 是 TensorFlow 团队开发的一款可视化工具，方便观察和调整机器学习的数据集、模型、超参数和训练结果等等。但是不知道为什么，PyTorch 调用 TensorBoard，要比 TensorFlow 方便简单得多，~~这何尝不是一种 NTR~~……

---

## 用法和效果

一个使用了 TensorBoard 的 torch 项目的主文件一般是这样的（把和 TensorBoard 无关的部分都注释掉了）：

```python
# imports
# import matplotlib.pyplot as plt
# import numpy as np

# import torch
# import torchvision
# import torchvision.transforms as transforms

# import torch.nn as nn
# import torch.nn.functional as F
# import torch.optim as optim

from torch.utils.tensorboard import SummaryWriter

# # transforms
# transform = transforms.Compose(
#     [transforms.ToTensor(),
#     transforms.Normalize((0.5,), (0.5,))])

# # datasets
# trainset = torchvision.datasets.FashionMNIST('./data',
#     download=True,
#     train=True,
#     transform=transform)
# testset = torchvision.datasets.FashionMNIST('./data',
#     download=True,
#     train=False,
#     transform=transform)

# # dataloaders
# trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
#                                         shuffle=True, num_workers=2)
# testloader = torch.utils.data.DataLoader(testset, batch_size=4,
#                                         shuffle=False, num_workers=2)

# # constant for classes
# classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
#         'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')

# class Net(nn.Module):
#     def __init__(self):
#         super(Net, self).__init__()
#         self.conv1 = nn.Conv2d(1, 6, 5)
#         self.pool = nn.MaxPool2d(2, 2)
#         self.conv2 = nn.Conv2d(6, 16, 5)
#         self.fc1 = nn.Linear(16 * 4 * 4, 120)
#         self.fc2 = nn.Linear(120, 84)
#         self.fc3 = nn.Linear(84, 10)
#     def forward(self, x):
#         x = self.pool(F.relu(self.conv1(x)))
#         x = self.pool(F.relu(self.conv2(x)))
#         x = x.view(-1, 16 * 4 * 4)
#         x = F.relu(self.fc1(x))
#         x = F.relu(self.fc2(x))
#         x = self.fc3(x)
#         return x
# net = Net()

# criterion = nn.CrossEntropyLoss()
# optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# default `log_dir` is "runs" - we'll be more specific here
writer = SummaryWriter('runs/fashion_mnist_experiment_1')

running_loss = 0.0
for epoch in range(1):  # loop over the dataset multiple times
    for i, data in enumerate(trainloader, 0):
        # # get the inputs; data is a list of [inputs, labels]
        # inputs, labels = data

        # # zero the parameter gradients
        # optimizer.zero_grad()

        # # forward + backward + optimize
        # outputs = net(inputs)
        # loss = criterion(outputs, labels)
        # loss.backward()
        # optimizer.step()

        # running_loss += loss.item()
        if i % 1000 == 999:    # every 1000 mini-batches...
            # ...log the running loss
            writer.add_scalar('training loss',
                            running_loss / 1000,
                            epoch * len(trainloader) + i) # 注意这一行！
# print('Finished Training')
```

正常情况下，使用了tensorboard 的项目在训练的过程中，可以用网页浏览器打开网址 `localhost:6006`，应该可以看到和下图类似但不同的画面：

![tensorboard](/photos/2022-04-08-tensorboard.png)

下面来仔细分解。

## 代码分解

[引入](python-import-script-module-package) TensorBoard 需要下面一行代码：

```python
from torch.utils.tensorboard import SummaryWriter
```

从名字就能看出来，`SummaryWriter` 是一个 class。粗略用了一下文档页面的业内搜索，好像整个 `torch.utils.tensorboard` 就只有这一个 class。

新建一个这个类的实例：

```python
writer = SummaryWriter('runs/fashion_mnist_experiment_1')
```

这一步会在当前工作环境下新建一个 `/runs` 文件夹，

要想显示导航栏上的“SCALARS”、“IMAGES”等等选项卡，并且让自己想观察的数据显示在各自类别的选项卡里，需要调用 `SummaryWriter` 下面的各种方法，比如 `add_scalar()`, `add_image()`.

### 各种方法

用法和效果举例如下：

- `add_scalar()`: 在一张图中画出**一个标量**指标随学习迭代的**变化曲线**。
    - `tag`: 图片的标题。
    - `scalar_value`: 指标的值，也就是纵坐标。
    - `global_step`: 全局迭代次数，也就是横坐标。
- `add_scalars()`: 在一张图中同时画出**多个指标**随学习迭代的**变化曲线**。
    - `main_tag`: 图片的标题
    - `tag_scalar_dict`: 一个字典，字典的键是变量的名字，值是各个变量的纵坐标。
    - `global_step`: 全局迭代次数，也就是横坐标。
- `add_custome_scalars()`: 没有用过，也没见到例子，不太明白。根据描述像是把之前 `add_scalar()` 和 `add_scalars()` 的结果重新组合，对 SCALARS 选项卡重新排版。每个 `SummaryWriter` 只能运行一次，可以在训练开始前运行，也可以在之后。
    - `layout`: 只有一个这参数，是一个字典，字典的键像是新图片/章节的名字，值是下一级字典或者是 `add_scalar()` 出现过/将要出现的 `tag` 参数。
- `add_figure()`: 显示 `matplotlib` 画出的**图表**。
    - `tag`: 标题
    - `figure`: 图表，要求类型为 `matplotlib.pyplot.figure`
    - `global_step`:迭代次数，效果如何 没试过。
- `add_histogram()`: 在一张图中画出一个样本的**直方图**，以及这个直方图随迭代变化的规律。这是个三维图片，x 轴是直方图的取值范围，y 轴是迭代次数，z 轴是直方图的频率值。
    - `tag`: 图片标题。
    - `values`: 一个 `torch.Tensor` 或者 `numpy.array` ，用于绘制直方图的样本.
    - `global_step`: 迭代次数，y 轴分量。
    - `bins`: 取样间隔参数，`numpy.histogram()` 中用到的。 ****
- `add_graph()`: 一般用于在训练前画出神经网络的**图状结构**。
    - `model`: 要画的模型，类型是 `torch.nn.Module`
    - `input_to_model=None`: （可选）输入模型的变量。
- `add_mesh()`: **三维点云**。
    - `tag`: 表格标题。
    - `vertices`: 顶点三维坐标的列表。
    - `colors`: 顶点的颜色。
    - `faces`: （可选）没看懂 (Indices of vertices within each triangle.)
    - `config_dict`: 用于画图的 ThreeJS 的参数。
    - `global_step`: 迭代次数。
- `add_embeddding()`: 神经网络的输入一般是高维向量，此工具将高维数据**投影到三维**空间，然后画出图像，方便我们感知训练集内样本之间的关系。
    - `mat`: 一个矩阵，每一行都是一个要处理的向量。
    - `metadata`: 标记文字，一般是列表。
    - `label_img`: 标记图片，显示在每个数据点旁边的
    - `global_step`: 迭代次数，一般没人用。
    - `tag`: 图片标题。
- `add_pr_curve()`: 准确率 (precision) -召回率 (call back) 曲线。准确率=真阳性/(真阳性+假阳性)，召回率=真阳性/(真阳性+假阴性)
    - `tag`: 图片标题。
    - `labels`: Ground truth 数据，每个数据点对应一个布尔值。
    - `predictions`: 模型的输出，每个数据点对应一个 [0,1] 之间的实数。
    - `global_step`: 迭代次数。
    - `num_thresholds`:用于画出 PR 曲线的阈值的数目。
- `add_hparams()`: 比较不同次运行之间的超参数。没太看懂。
    - `hparam_dict`: 超参数的名称和取值
    - `metric_dict`: metric （不知道怎么翻译）的名称和取值
    - `hparam_domain_discrete`: （可选）字典，超参数的名称和有限个可能的取值。
    - `run_name`: 运行的名称，将会成为 `logdir` 的一部分。
- `add_image()`: 在 IMAGES 选项卡中显示**一张图片**。
    - `tag`: 图片名称。
    - `img_tensor`: 一个 `torch.Tensor` 或者 `numpy.array`，被显示的图片。对应于下面的 `dataformats` 参数。
    - `global_step`: 迭代次数，没见有人在显示图片的时候用过。
    - `dataformats=’CHW’`: 图片各维度的顺序。默认是“颜色-高度-宽度”。
- `add_images()`: 并列显示**多张图片**。
    - `tag`: 图片组的标题。
    - `img_tensor`: 一个 `torch.Tensor` 或者 `numpy.array`，被显示的图片。图片个维度的含义由 `datadormats` 给出。
    - `global_step`: 迭代次数，没见有人在显示图片的时候用过。
    - `datadormats=’NCHW’`: 图片各维度的顺序。默认为“图片序号-颜色-高度-宽度”。
- `add_video()`: 略
- `add_audio()`: 略
- `add_text()`: 略

.py | TensorBoard 笔记（PyTorch 版）

以官网给出的文件结构为例来说明：

```

sound/ Top-level package
 __init__.py Initialize the sound package
 formats/ Subpackage for file format conversions
 __init__.py
 wavread.py
 wavwrite.py
 aiffread.py
 aiffwrite.py
 auread.py
 auwrite.py
 ...
 effects/ Subpackage for sound effects
 __init__.py
 echo.py
 surround.py
 reverse.py
 ...
 filters/ Subpackage for filters
 __init__.py
 equalizer.py
 vocoder.py
 karaoke.py
 ...
```

## 使用现成的 python 代码

正常的编程语言教程，教人配置完开发环境之后就应该进入正题，开始讲语法了。但是咱不正常，所以先来谈谈怎么用别人已经写好的代码。其中最简单的，就是可以直接通过包管理程序安装的：

```bash

pip install sound
```

然后想要使用某个文件中的函数，比如假装 `wavwrite.py` 中有个函数叫 `write()`，以下写法都是可以的，注意不同 import 方法对应不同的函数调用写法：

```python

import sound
sound.formats.wavwrite.write()

from sound import formats
formats.wavwrite.write() 

from sound.formats import wavwrite
wavwrite.write()

from sound.formats.wavwrite import write
write()
```

但是，不是所有的 python 代码都可以直接安装，比如一篇论文的研究成果发表之后，处理数据的代码也往往开源，但是这些作者基本上就只是把自己写代码的文件夹公开出来而已，我们把文件夹下载下来，然后直接 `import sound`, 会报错，提示找不到名为 sound 的库。

## python 如何读取代码文件

仔细想想，找不到才是正常的，之前轻轻松松的一句 `import sound`就解决问题，这才不简单——不同的库往往位于文件系统的不同位置，但我们只要写出他们的名字就行了，不需要指定文件路径。电脑硬盘那么大，找到库却几乎是瞬间完成的。

这是因为 python 并没有搜索整个硬盘。有一个变量，一般名为 `PYTHONPATH`，其变量值是一个列表，表中成员是含有 python 库文件夹的路径。当我们在命令行输入命令的时候，电脑会：

- 搜索当前所在的文件夹，也就是在命令行输入 `python` 时终端所在的文件夹。
- 遍历 `PYTHONPATH` 中的文件夹。
- python 包管理程序默认的位置，一般是 `<path to python>/site-package`。

看看有没有我们要引用的库，找到了就引入，找不到就报错。

上一节的错误中，如果我们恰好位于 sound 所在的文件夹，然后运行 python，此时第一条生效， `import sound` 不会报错，但在其他位置就不行了。

## 名词解释：interactive, script, module, package

可执行的 python 命令可以出现在以下四个地方，第一种是接受键盘输入的程序，后三种都是文件：

1. interactive: python **交互式界面**，也叫做 calculator mode，也就是在命令行输入 `python`之后出现的界面。每次输入一句，结果在命令行上显示出来。当 python 退出之后，输入过的命令就消失了。
2. script: python **脚本**文件，也就是在命令行输入 `python somefile.py`里面的那个`somefile.py`。
 1. 毕竟 python 是一种很轻量化的语言，在一定程度上可以起到 shell 的作用，有些命令我们并不想要用完就扔，而是保存起来以便以后重复执行，另外很多命令的组合组合成函数也可以极大地简化工作。在这种语境之下, interactive 和 script 的关系，就好像 Linux 命令行和 bash script 的关系一样。
 2. 但同时 python 又是一种功能很全面的语言，完全可以胜任复杂的面向对象编程。在这种语境之下，script 也可以用来指代 main module，也就是程序执行的主文件和入口，和下面的一般的 module 相区分。
3. module: python **模块**文件，也就是在命令行输入 `python -m another` 里面的那个 `another`（注意这里不写拓展名 `.py`）。按照官方文档的说法，所有 `.py` 文件都是 module。但是实际上这句话很有误导性，上一节的 main module 和一般的 module 非常不同，下一节会详细展开讲。一般提到 module，都是在强调这个文件定义的变量和函数可以被其他的 python 文件引用。
4. package: python **包**，互相关联的 modules 构成的更高一级的可供引用的结构，简单理解就是含有 `__init__.py` 的文件夹，但是 python 并不是根据文件夹和文件之间的从属关系来确定 package 和 module 之间的关系的，下一节会详细展开讲。

## script vs. module

python 同时兼具脚本语言的灵活性，和各种重型语言的功能全面性。因为前者，所以它并不要求程序作者一定要在一个叫做 `main.py` 的文件里写一个名叫 `Main` 的类, 然后在里面实现一个 `main()` 方法。但是因为后者，没写不代表 python 不需要知道一个复杂程序执行的起点。

这个起点就是不带有 `-m` 参数的 `python` 命令后面跟着的 `.py` 文件，这就使得这个文件变得比其他 `.py` 文件特殊。底层表现就是 python 会不管这个文件的名字叫什么，都将它的 `__name__` 属性赋值为 `"__main__"`。这样，即便这个文件可能是一个大型库中间的一个模块，运行的时候 python 连它的真名都不知道，就更找不到它同级和上下级的其他模块了。

各种普通模块被 python 用到的方法就是通过在主模块 main module（或者说 script）中 import。经过“python 如何读取代码文件”一节中的搜索过程之后找到了所需模块或包，模块的名字、模块之间的关系、模块里定义了哪些属性和函数，就被 python 了解了，从而当主模块召唤他们的时候就知道去哪里找相应的代码。除了在被 import 的时候，`python -m` 命令的宾语也可以告诉 python 被运行的模块和包的相对关系：`python -m sound.formats.wavwrite` ，此时 python 执行了 `wavwrite.py` 中的所有可执行的命令，同时知道从 `sound/` 到 `wavwrite.py` 的各个包之间的关系。

## absolute import vs. relative import

开头使用已经安装过的包使用的语法全都是绝对引用 (absolute import)，表现就是 import 语句里面没有以 `.` 作为开头的。

另外一种 import 方法叫相对引用 (relative import)，`.` 表示模块所在的文件夹，`..` 表示模块的上一级文件夹。主要用在各种明确知道自己是工具代码，而且是一个更高层次结构的组成部分，几乎永远不需要被作为主模块运行的代码。

回到开头例子里的文件结构，假如 sound/effects/surround.py 中想要使用 sound/formats/wavwrite.py 和 sound/effects/echo.py 中的函数，可以写成：

```python

# in sound/effects/surround.py
from ..formats import wavwrite
from . import echo
```

## 如何组织代码，以便自己重用

研究终于推进到了准备写论文的阶段了（学渣本质暴露了），写草稿之余，之前几年时间里做过的处理和分析，接下来的一两个月里需要把工作流程规范化之后迅速重做一遍确认。

随手写散落各处的分析代码需要整理到一起，之前试图统一到一个项目之下，结果总是在某个模块引用其他模块的时候遇到报错。于是才有了这篇文章。

以下是 [这篇文章](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510) 给出的一个推荐的项目文件结构：

```

|- notebooks/
 |- 01-first-logical-notebook.ipynb
 |- 02-second-logical-notebook.ipynb
 |- prototype-notebook.ipynb
 |- archive/
	 |- no-longer-useful.ipynb
|- projectname/
 |- projectname/
	 |- __init__.py
	 |- config.py
	 |- data.py
	 |- utils.py
 |- setup.py
|- README.md
|- data/
 |- raw/
 |- processed/
 |- cleaned/
|- scripts/
 |- script1.py
 |- script2.py
 |- archive/
 |- no-longer-useful.py
|- environment.yml
```

学过这篇笔记包含的内容，我才理解作者这样的安排。既然主文件 ~~很难~~ 没办法通过相对引用来找到工具代码，索性就把工具代码写成一个完整可安装的库，然后就像 `numpy`, `pandas` 一样在独立的 notebook 和 scripts 中引用。

实际使用的时候，需要安装 `projectname` 下的代码：

```bash
cd projectname
pip install -e .
```

要知道为什么这样做，需要理解 `setup.py` 这个文件。这篇文章已经够长了，所以这个话题还是下次再说吧。

## 参考链接

- [What's the difference between a Python module and a Python package?](https://stackoverflow.com/questions/7948494/whats-the-difference-between-a-python-module-and-a-python-package). all python files re modules, while package is a specific kind of modules. It is a subsection of module in the python documentation.
- Official explanation of python module: [https://docs.python.org/3/tutorial/modules.html](https://docs.python.org/3/tutorial/modules.html)
- [This stackoverflow answer: "run as module" is different from "run as script".](https://stackoverflow.com/questions/14132789/relative-imports-for-the-billionth-time) run as module sets the "name" to the module's name, while running as script sets it to `__main__` . Here we use "name" instead of `__name__` because it also contains `__path__` in newer versions.
- A tutorial for project organization: [https://realpython.com/python-application-layouts/](https://realpython.com/python-application-layouts/)
- Official about packaging: [https://packaging.python.org/en/latest/tutorials/packaging-projects/](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
- Gist: How to organize data science project: [https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510)
- From the gist there is a link: [http://drivendata.github.io/cookiecutter-data-science](http://drivendata.github.io/cookiecutter-data-science)

.py | import 引用现成的代码


马上要参加一个暑期学校，关于深度学习在显微图像处理当中的应用。

深度学习是机器学习的一个分支，机器学习中的绝大多数数据都可以抽象为向量（一阶张量），绝大多数的算法都可以分解为向量之间的运算，或者对向量的变换，表示为矩阵（二阶张量）。这就对张量计算相关算法的库函数产生了很大的需求。PyTorch 和 TensorFlow，还有其他的一些库，比如 Keras，Caffe 等等等等，都是为此而生。早期版本的 pytorch 和 tensorflow 有很大的区别，但是随着版本的迭代，两者逐渐兼并和挤掉了其他的竞争者，两者的相似之处也越来越多，“变成了自己曾经最讨厌的样子”。lol

不知道课上究竟要使用哪种机器学习的框架，所以决定把 PyTorch 和 TensorFlow 全都安装了（摊手）。正好可以接着上一篇的 [python 教程](python-interpreter-editor-virtualenv) 往下写。

先说一下自己的软硬件环境：Intel 家的 CPU 和集成显卡（玩不了《文明6》）。虽然不在官方支持 Linux 的名单上，但是自己安装了 Fedora，内核更新了几次之后已经没有了兼容性问题。python 版本 3.9.6，包管理器是 pip，编辑器是 vscode。

## 建立虚拟环境

为什么要建立虚拟环境的问题本系列的前一篇已经回答过了，这次直接开干。我给两个虚拟环境分别取名为 `torch` 和`tf` 。关于命令行部分的代码，为了表示各个虚拟环境，特别加上了命令提示符`(env)[me@mycomputer]$`，抄代码的时候注意去掉。

```bash

[me@mycomputer]$ mkvirtualenv torch
(torch)[me@mycomputer]$
```

## 安装

在 PyTorch 官网，找到自己的硬件配制对应的安装命令：[https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)。比如我的就是 `Stable`>`Linux`>`Pip`>`Python`>`CPU`。把生成的命令复制到命令行：

```bash

(torch)[me@mycomputer]$ pip3 install torch==1.9.1+cpu torchvision==0.10.1+cpu torchaudio==0.9.1 -f https://download.pytorch.org/whl/torch_stable.html
```

等待各种提示信息显示安装完成。

## 验证和退出

按照 [官网给出的方法](https://pytorch.org/get-started/locally/#linux-verification)，验证安装是否成功：

```python

import torch
x = torch.rand(5, 3)
print(x)

# tensor([[0.3799, 0.4494, 0.4296],
#       [0.5800, 0.0180, 0.3110],
#       [0.9847, 0.0125, 0.2648],
#       [0.0296, 0.3142, 0.9266],
#       [0.3192, 0.9645, 0.5545]])
```

为了下一步安装 tensorflow，先要退出到默认的虚拟环境：

```bash

(torch)[me@mycomputer]$ deactivate
[me@mycomputer]$
```

## 说好的 TensorFlow 呢

本来这篇文章是打算把  pytorch 和 tensorflow 一起写了，结果 tensorflow 实在是不给力。

- 直接安装

在 [TensorFlow 的官网](https://www.tensorflow.org/install)上方导航栏找到 install 按钮，然后在页面左侧找到 package/pip，[安装命令](https://www.tensorflow.org/install/pip#3.-install-the-tensorflow-pip-package)也是只有一句话

```python

pip install --upgrade tensorflow
```

然而不行，虽然安装过程中没有报错，但是验证安装的时候报出一堆错误。

报错信息里有一句 `Could not load dynamic library 'libcudart.so.11.0'`，怀疑上面命令安装的是 GPU 版本。

- 安装 CPU 版本

在网页正文的“Package Location”一节找到了 CPU 版本的安装文件：`https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow_cpu-2.6.0-cp39-cp39-manylinux2010_x86_64.whl`，于是删除虚拟环境、重建虚拟环境、重新安装。

```bash

(tf)[me@mycomputer]$ deactivate
[me@mycomputer]$ rmvirtualenv tf
[me@mycomputer]$ mkvirtualenv tf
(tf)[me@mycomputer]$ pip install --upgrade pip
(tf)[me@mycomputer]$ pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow_cpu-2.6.0-cp39-cp39-manylinux2010_x86_64.whl
```

运行官方提供的测试之后依然会有警告信息：

```bash

(tf) [shixing@yoga-laptop ~]$ python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
20XX-XX-XX XX:XX:XX.XXXXXX: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
tf.Tensor(-1338.4773, shape=(), dtype=float32)
```

[stackoverflow 的这个回答](https://stackoverflow.com/questions/47068709/your-cpu-supports-instructions-that-this-tensorflow-binary-was-not-compiled-to-u) 说，需要从源码编译 tensorflow，具体的方法在[官网也有](https://www.tensorflow.org/install/source#linux)，但是实在是太麻烦了，~~（还是鸽了）~~ 下次单独写成一篇吧。

.py | Fedora 上安装 CPU 版 pytorch


上一篇 《[在 Windows 10 上配置 python 开发环境](python-installation-and-configuration)》 很惭愧，只做了一点微小的工作，大概三件事：
- 一个，安装了 python 的解释器；
- 第二个，把 vscode 安装进了电脑；
- 第三个，就是我们知道的 virtualenv 虚拟环境。

如果说还有一点什么要讲的，就是在 how 之外，讲一点 what。为了让文章更通顺一点，我打算调整一下顺序，先讲编辑器，再讲解释器，最后再说虚拟环境。虽然文章是立足于 python 来谈，但是这些知识适用于几乎所有通用编程语言。因为我也不是计算机专业出身，这篇文章只是我的学习笔记，如果有不对的地方欢迎大家指出。

## 编辑器

首先我们来做一个实验，把上次教程里创建的 python 文件 `hello.py` 重命名，把拓展名 `.py` 改成 `.txt`, 然后双击鼠标打开文件，会发生什么？在 Windows 系统里，会弹出最最普通的记事本窗口，窗口里是白底黑字的 python 语句，不像 vscode 里面不同语句有不同颜色，但是内容完全一样。

甚至更进一步，你可以在命令行里直接让 python 编译器执行 `.txt` 文件的内容，（`py -m hello.txt`）效果和 `.py` 也是一样的。

`.py` 这个拓展名什么也没有做，和 `.txt` 文件一样，内容就是一串我们人类能够读懂的字符，这样的文件叫做[文本文件](https://zh.wikipedia.org/wiki/%E6%96%87%E6%9C%AC%E6%96%87%E4%BB%B6)。处理文本文件的程序，就叫做[编辑器](https://zh.wikipedia.org/wiki/%E6%96%87%E6%9C%AC%E7%BC%96%E8%BE%91%E5%99%A8)。记事本就是一种编辑器，vscode 也是。

既然记事本就可以编写 python 代码，那我还费劲安装 vscode 干嘛？确实有人真的只用记事本或其他操作系统自带的编辑器写 python 代码，（油管上还有一个视频是用 Microsoft Word 写代码；）然后用命令行调试程序，但是 vscode 毕竟是专为程序员而开发，提供了很多默认编辑器不具备的功能，比如前面提到将函数、变量、保留词显示成不同的颜色的语法高亮功能。

## 编译器 / 解释器

除了文本文件，这篇文章里涉及的第二种文件是[二进制文件](https://en.wikipedia.org/wiki/Binary_file)。

电脑并不能直接看懂人类认识的字符，在一切的最底层，经典计算机认识的是以不同方式表示的 0 和 1。虽然说所有文件在底层都是二进制的文件，但是“二进制文件”这个名词一般专门用来表示除了文本文件之外的文件，又因为图片文件、视频文件啥的都有自己的名字，所以这个词用来指代的文件，基本上都和软件程序，可以让计算机执行的文件有关。

人类只认识字符，计算机只认识 0 和 1，那么最直觉的思路就是把文本文件翻译成二进制文件。这个翻译过程叫做[编译](https://en.wikipedia.org/wiki/Compiler)，能够完成这一过程的软件就叫做编译器。编译器编译完成之后就退出了，要想执行程序，电脑直接执行编译之后的可执行文件就可以了。

但是编译存在一个问题，就是整个软件需要在所有的源代码文本文件都写好的情况下才能被编译成软件，编译耗费的资源和时间随着软件规模的增长而扩大；一旦修改某处，整个项目又要重新编译。很多时候我们只想快速地知道某个大型项目中的某一句命令的效果是什么，编译这种方法就不适合这种场景了。

于是就出现了[解释器](https://en.wikipedia.org/wiki/Interpreter_(computing))，这种程序比编译器复杂的多，在我们执行这种编程语言命令的时候始终运行，允许我们一句一句地输入命令，记得代码的上下文，还记得我们之前命令的结果，代价就是对于大型项目也需要一句一句地分析解释，计算资源的开销和速度都不如编译。

python 就是一种（官方实现）使用解释器的编程语言，我们在官网下载的那个 `python-***.exe` 文件就是 python 的解释器。这也导致了 python 程序的性能往往不如同水平的 C/C++ 程序员写出来的程序，但是由于单句执行适合试错，所以在 ~~经常犯错的~~ 科研领域还挺流行的。

当然了，python 的特点远不仅仅是解释型语言这么简单，它还是一种：
- [脚本语言](https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html)
- [动态语言](https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html)
- [面向对象语言](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)
- [函数式编程语言](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)
- [……](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)

## 虚拟环境

有一次我问我女朋友，她写 python 用什么 IDE，她很自豪地回答，她的 Macbook 自带 python，直接在命令行就可以运行……答非所问还不是最大的问题（仔细想想好像也不是答非所问，不过只回答了问题的一部分），而是直接在命令行运行系统自带的 python，或者其他编程语言的解释器或者编译器，本身就是编程初学者常干的一种危险行为。

Windows 还好，毕竟这是一个面向广大家用消费者的操作系统，防呆设计还是挺多的，没有原装的 python。更加极客向的操作系统，比如 Linux 和 BSD 家族可就不一样了，这些操作系统（的发行版）往往预装了 python。这个 python 可不是给用户拿来开发自己的程序用的，而是用来让很多 python 语言写成的操作系统工具调用的。既然如此，这个 python 的版本一般由发行版的安装包管理者来控制，往往落后最新的 python 版本一段时间，为了避免新版本 python 有什么 bug，也为了让操作系统工具的开发者有时间更新自己的代码。所以如果直接用这个版本的 python 做开发，而且不小心自己升级了 python 的版本，很有可能导致系统的某些功能失常。

虚拟环境就是 python 对这个问题的解决方案。我们可以安装不同于原装 python 的版本，但是并不将这个解释器加入系统路径，操作系统也就不知道这个版本 python 的存在。创建虚拟环境的时候，我们指定使用这一特定版本的 python，这样在虚拟环境激活之后就是我们开发需要的 python，退出虚拟环境就是系统工具使用的 python。

另外，即便两个项目适用于同一个 python 版本，而且都是系统自带的这个版本，虚拟环境也有用武之地。绝大多数程序都需要依赖别人写好的工具代码，这些代码叫做库 (library)，不同的项目可能依赖不同的库代码，或者同一个库的不同版本。这个时候，可以创建不同的虚拟环境，并在其中安装各个项目对应的库，项目之间可以互不影响。

## 编辑器 + 解释器 / 编译器 + 虚拟环境管理 + …… = IDE

为了开发 python 程序要安装这么多不同的程序，太麻烦了，就不能一键安装全搞定吗？当然可以了，这种集成了开发过程中用到的各种工具的程序，就叫做[集成开发环境 (IDE)](https://zh.wikipedia.org/zh-cn/%E9%9B%86%E6%88%90%E5%BC%80%E5%8F%91%E7%8E%AF%E5%A2%83)。对于 python，最有名的 IDE 当属 [Anaconda](https://www.anaconda.com/) 了。

那我为什么不用呢？当然用过，但是听说了 vscode 的大名，而且尝鲜之后，就再也回不去了。写 python 需要编辑 `.py` 文件，写博客需要编辑 `.md` 文件，博客的一些功能需要 JavaScript 实现，这些事情本质上都是编辑文本文件这一件事，在 vscode 这样的编辑器里全搞定就再自然不过了，那么 Anaconda 里的 Spyder 和 Jupyter Lab 就显得多余了。

“把一件事做好”，这也是 [Unix 哲学](https://zh.wikipedia.org/wiki/Unix%E5%93%B2%E5%AD%A6)的一部分。但是问题在于，不同的人对于“一件事”的定义是不同的，有些人觉得做早饭是一件事，有些人觉得是热牛奶煎鸡蛋烤面包等等好几件事，谁是对的？

也许都对，但是 编辑器 + 解释器 + …… 比起 IDE 就是处在鄙视链的上游。这一点可以不同意，但是应该要知道，不然别人抖包袱的时候你没捧上哏，挺尴尬的。


.py | 笔记：python 编辑器、解释器、虚拟环境


我的 python 版本之前一直停留在 3.7，目前最新已经到了 3.9。最近研究上要用一段别人写的 python 的代码，原作要求 3.6 版本的 python，所以卸载了 3.7 版本，重新安装了 3.9 和 3.6 两个版本的 python。

煽动爸妈学编程很久了，欠他们一篇教程。不论是打算不断精进者的第一门编程语言，还是浅尝辄止者打算学的唯一一门语言，python 都是一个很不错的选择。所以即便爸妈对编程可以说是毫无兴趣，我也还是把这篇教程写完了，希望能帮到其他人。因为是面向纯新手的，所以基于 Windows 10 操作系统。因为这套设置我自己也要用，出于个人偏好，所以没有直接使用 `conda`。

## ~~别看你今天闹得欢~~ 先拉个清单
- python
    - 在官网下载 `python` 解释器
    - 安装 `python` 解释器
- 虚拟环境
    - 设置环境变量
    - 用 `pip` 安装 `virtualenv` 
    - 用 `pip` 安装 `virtualenvwrapper`
    - 创建一个虚拟环境，安装 `jupyter`
- 编辑器
    - 在官网下载 `vscode`
    - 安装 `vscode` 和相关插件
    - 测试一下效果

## 教程本体

### 在官网下载 `python` 解释器

在 python 的官网上 ([https://www.python.org/downloads/](https://www.python.org/downloads/)) 下载

![](/photos/2021-03-07-python-official-website.png)

### 安装 `python` 解释器

执行下载的文件，可以看到如下图所示的界面，点击红框中的选项，因为我想更改安装路径。此处似乎也可以勾选最下面的 "Add Python 3.9 to PATH"，我安装的时候没有选，后面才发现还要手动完成这一工作。

![](/photos/2021-03-07-python-install.png)

接下来的界面里每个选项都勾选，next。

![](/photos/2021-03-07-python-next.png)

在接下来出现的界面中，选择 "Install for all users"，然后选择一个自己喜欢的安装路径。我之所以选择 `C:\Python39` 这个位置，是因为:
1. C 盘是系统盘，而且是固态硬盘，比较快；
2. 默认路径在个人文件夹里，非常难找
3. `C:\Program Files` 需要管理员权限，用 `pip` 做软件包管理不方便。

![](/photos/2021-03-07-python-install-path.png)

安装完成后进入命令提示符，输入 `py`，应该可以看到一串 python 版本信息，然后命令提示符变成 `>>>` 字样，此时就已经进入了 python 环境，可以按行运行 python 命令。输入 `exit()` 就可以退出 python。

### 设置环境变量

在 windows 的搜索框里输入 "environment variables"，没等你输完，应该就可以看到下图中的联想结果：

![](/photos/2021-03-07-environment-variable-search.png)

再按照下图，依次点击按钮，一共要做两件事:
1. 给 `Path` 变量添加 `C:\Python39` 和 `C:\Python39\Scripts` 两个新值。
2. 新建一个文件夹，用于存放 python 的虚拟环境（比如 `C:\PythonEnvs`）。创建一个名为 `WORKON_HOME` 的新变量，并将其值设为 `C:\PythonEnvs`.

![](/photos/2021-03-07-environment-variable-box.png)

### 用 `pip` 安装 `virtualenv` 和 `virtualenvwrapper`

按照刚才的步骤，此时 `pip` 应该已经安装，此时在命令行输入途中的命令，应该可以看到类似的返回信息：

![](/photos/2021-03-07-pip-check.png)

如果命令行说没找到 `pip`，可能需要按照[这个链接](https://pip.pypa.io/en/stable/installing/#installing-with-get-pip-py)里的方法重新安装。

在命令行中输入 `py -m pip install virtualenv`， 安装虚拟环境管理器：

![](/photos/2021-03-07-virtualenv-install.png)

显示安装成功之后，在命令行输入 `py -m pip install virtualenvwrapper-win`，结果应该和上图差不多，忘了截图。

### 创建一个虚拟环境，安装 `jupyter`

`virtualenv` 和 `virtualenvwrapper` 安装完成之后，在命令行中输入 `mkvirtualenv base`，新建一个名为 base 的虚拟环境。

然后输入 `workon base`，此时命令提示符的行首应该会多出一个 `(base)` 字样，这说明我们已经工作在了 base 这个虚拟环境里。此时 `pip --version` 的结果说明我们的 python 的地址已经和之前不同了。

![](/photos/2021-03-07-virtualenvwrapper-check.png)

在这个环境之下，安装 jupyter，输入命令 `pip install jupyter`，安装 jupyter。这一步不是必须的，但是这样我们将来安装 vscode 之后，可以获得和 conda 自带的 spyder 类似的体验，菜鸟逐行调试的时候非常方便。

### 下载和安装 `vscode`

从 vscode 的官网下载安装包（[链接在此](https://code.visualstudio.com/)），可以看到大大的下载按钮：

![](/photos/2021-03-07-vscode-download.png)

下在之后的安装过程就和一般的程序安装一样（安装很久了，没有截图）。

安装完成之后打开程序，点击左侧工具栏红框中的那个图标，搜索 python 的相关 vscode 插件。python 开发一般都需要 `python`, `pylance`, `jupyter` 这三个：

![](/photos/2021-03-07-vscode-plugin.png)

以后要运行 vscode 的时候，在你想开始写代码的文件夹里，鼠标右键单击，选择 "Open with Code":

![](/photos/2021-03-07-vscode-folder-open.png)

然后在 vscode 的界面，在文件树上单击红框中的按钮，新建一个文件，命名为 `*.py`，这里随便写了个 "hello".

![](/photos/2021-03-07-vscode-new-file.png)

在随后打开的文档编辑区输入 `print("Hello World")`，将光标停留在这一行，按 `Shift`+`Enter` 执行这一行：

![](/photos/2021-03-07-vscode-run.png)

因为是第一次执行，又因为安装了 `jupyter`，这时候 vscode 的右下角应该会出现一个提示框，询问是否用 jupyter interactive window 执行代码。然后关掉下方的这个 terminal (下半区右上角的叉号)。重新按 `Shift`+`Enter` 执行，此时的结果应该如下图，点击红圈中的变量浏览器，这就几乎和 spyder 的体验一样了。

![](/photos/2021-03-07-vscode-interactive.png)


.py | 在 Windows 10 上配置 python 开发环境


“图”这个字在英语中可以对应好几个词，picture, image, figure, plot... 其中的 plot，意思是展示两组或两组以上的数据之间关系的图像。用时髦一点的话说，就是数据可视化的产物。  

所谓`matplotlib`，顾名思义，~~`mat` 表示山寨 MATLAB~~，`plot` 的含义如上所述，`lib` 表示这是 python 的[一个第三方库 (library)，而不是某种领域专用的编程语言 (domain specific languange, DSL)](http://www.yinwang.org/blog-cn/2017/05/25/dsl)。

所谓 API，全称是 application programming interface, 应用程序接口，约等于在你有了自己的数据，想调用 matplotlib 来画图的时候，那些需要写在你自己代码里的语句的语法规则。

因为是代码库，所以在一切开始之前，需要在你的 python 代码开头声明引入

```python
import matplotlib.pyplot as plt
```

`plt` 可以换成你喜欢并且不和其他代码冲突的名字，但是这三个字母是大家的约定俗成的，网上的绝大多数示例代码都这么写，~~照抄就完事了。~~

## `matplotlib` 的两种 API

`matplotlib` 有两种 API，（其实还有第 3 种 `pylab`，但它没能经得起时间的检验，已经处于官方极不推荐的状态），分别是：

- 基于状态的 (state-based)
- 面向对象的 (object-oriented)

两种风格混用的话大概率没法玩得转，会产生各种出人意料的输出结果，新手 debug 的能力又比较差，所以最好先选边站队，有时间再学剩下的一个。

对于有 MATLAB 基础的朋友，基于状态的 API 语法和 MATLAB 几乎一模一样，几乎可以直接上手，当年 python 算是后起之秀，这一招当初就是为了从 MATLAB 那里吸引用户， ~~相当歹毒。~~ 这套接口本身也比较简单，适合在调试程序的时候快速看一下结果，检查错误。

对于一般的初学者，matplotlib 的代码本身就是用面向对象的编程范式写成的，学习这套 API 可以更好的理解代码，知道自己究竟在干什么，顺便还可以熟悉一下面向对象的编程范式。现在学 python 之前就会 MATLAB 的人越来越少，网上 ~~可供复制粘贴~~ 的示例代码越来越多地使用面向对象的语法，学习面向对象的接口也更加实用。

## 两种 API 的相同任务

![](/photos/2020-10-04_figure-and-axes.png)

上图来自网上随便找的一篇论文，可以看到，一般我们会把信息相关的几幅小图放在一起，在文章排版的时候，这张组合在一起的图片算作一个单位。在 matplotlib 里面，这样一个基本单位叫做 `figure`，而每一幅小图叫做 `axis` （变量名常简写作 `ax`）。平时的单图可以看作只有一个 `axis` 的 `figure`，多图的时候往往用一个 tuple `axes` 的 `__getitem__()` 方法来控制每个子图。

![](/photos/2020-10-04_anatomy-of-figure.png)

上图[来自官网](https://matplotlib.org/gallery/showcase/anatomy.html#anatomy-of-a-figure)，图中的蓝字就是 matplotlib 认为的一张只有一个 axis 的 figure 所包含的元素。

两种 API 要做的事情，就是建立 `figure` 和 `axis`，然后提供函数/方法来生成或者改变各个元素。

## 基于状态 (state-based)

所谓基于状态的 API，不太好解释，前面已经说过，在每个函数前面加上 plt，剩下的就和写 MATLAB 几乎完全一样。

看[官网给出的教程](https://matplotlib.org/tutorials/introductory/pyplot.html#sphx-glr-tutorials-introductory-pyplot-py)，可以观察到两个有趣的现象：

- 几乎没有赋值运算符 `=`
- 几乎所有的 `.` 前面都是 `plt`

也就是说，与 matplotlib 相关的命令都是函数，而且不需要将返回值赋给任何变量。`figure` 和 `axis` 的概念被隐藏起来了，`plt.figure()` 建立一个 figure；`plt.subplot()`建立多个 axes，并且将程序的注意力放到函数参数指定的子图上；紧跟着的设定各种元素的函数都会作用到之前最新一个 `plt.subplot()` 所指定的子图上。

没有赋值说明函数的返回值并不重要，这些函数都会作用在后台维护的 figure 和 axis 的状态机上面，也就是说这些函数都有副作用，不是纯函数。

## 面向对象 (object-oriented)

[作为对比](https://matplotlib.org/gallery/showcase/anatomy.html#anatomy-of-a-figure)：

- 头几句会有赋值运算符 `=`，被赋值的变量名一般就是 `fig` 和 `ax`。
- `.` 前面都是 `fig` 和 `ax`，其中 `ax` 居多。

`fig` 和 `ax` 分别是 `matplotlib.figure.Figure` 和 `matplotlib.axes.Axes` 两种对象的实例，画图和调整都是在调用两种对象的方法，主要是 `ax` 的方法。

## 不同之处 Cheat Sheet

绝大多数命令，在两种 API 之下的名字都一样，差别就在于开头究竟是 `plt.` 还是 `ax.`，但是少数命令不同，下面做了一个表格，进行一个不完全的列举：

| State-Based | 任务 | Object-Oriented |
|---|---|---|
|`plt.figure(**args)`|__新建 figure__|`fig = plt.figure(**args)`|
|`plt.subplot(**args)`|__新建 axis__|`ax = fig.add_subplot(**args)`|
|好像没有|__同时新建 figure 和复数 axes__|`fig,axes = plt.subplots(**args)`|
|`plt.title(**args)`|__设置 figrue 标题__|`ax.set_title(**args)`|
|`plt.xlabel(**args)`|__设置 x 轴名称__|`ax.set_xlabel(**args)`|
|`plt.ylabel(**args)`|__设置 y 轴名称__|`ax.set_ylabel(**args)`|
|`plt.xlim(**args)`|__设置 x 轴范围__|`ax.set_xlim(**args)`|
|`plt.ylim(**args)`|__设置 y 轴范围__|`ax.set_ylim(**args)`|

其他不同的命令，以后用到的时候会随手更新。


.py | matplotlib笔记：两种API

当初博客开张的时候，原计划在编程语言方面聊聊 C++、Java 和 Python。谁曾想半年多过去了，尚未写过 Python 的帖子。实在是说不过去啊！所以今天赶紧写一篇来凑数。

其实俺接触 Python 的时间，也不算太早（大概是2003年那会儿）。当时看到 Eric Raymond 关于几大编程语言的评价（原文在“这里”，翻译在“这里”），之后又看了他写的《Why Python?》。感觉这位大牛蛮器重 Python 滴，于是俺也就跟风学习了一番。从此一发不可收拾——现在 Python 已然成为俺最常使用的脚本语言了。

接下来，俺就从几个不同的角度来鼓吹一下 Python。假如你从来没有听说过或者从来没用过此语言，听了俺的忽悠之后，或许会有所心动 :-) 假如你觉得俺只不过是 Python 阵营的枪手，发发广告帖，那你就不用再浪费宝贵的时间去看后续的帖子了。

按照俺先前的习惯，会把接下来的内容拆成几个帖子来写......

为了方便阅读，把本系列帖子的目录整理如下（需翻墙）：

1. [作为脚本语言的 Python](RP-why-choose-python-1-script)
2. [作为动态语言的 Python](RP-why-choose-python-2-dynamic)
3. [作为面向对象语言的 Python](RP-why-choose-python-3-oop)
4. [作为函数式编程语言的 Python](RP-why-choose-python-4-fp)
5. [作为瑞士军刀的 Python](RP-why-choose-python-5-tool)
6. （未完待续）


> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
>
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html">https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html</a>

.py | 转载：为什么俺推荐 Python[0]·概述

### 文章目录

* [脚本语言好在哪？](#pros)
* [脚本语言有啥缺点？](#cons)
* [Python 和其它脚本语言的比较](#compare)
* [总结](#summary)

俺窃以为，Python 的所有特征中，作为脚本语言（“脚本语言”的定义参见“[这里](https://en.wikipedia.org/wiki/Scripting_language)”）是它的首要特征。因此，在本系列帖子中，俺首先来忽悠一下 Python 作为脚本语言，有些啥好处？

# 脚本语言好在哪？<a name="pros"></a>

要聊 Python 作为脚本语言的好处，首先得说说脚本语言自身有哪些优点。一般来说，当我们提及“脚本语言”，都是强调其解释执行的特性（虽然有些脚本语言也支持编译）。所以，后面陈述的这些优点，大都是拿编译型语言来进行对比。

## 更高层次的抽象和封装

大部分脚本语言都提供了（内置了）比较高层次的抽象和封装。像很多脚本语言都内置了字符串处理能力以及正则表达式（典型代表就是 Perl）。还有很多脚本语言都内置了高级的数据结构。比如 Python 在语言层面支持了链表（Python 的术语叫 List）、映射（Python 的术语叫 Dict）、元组（Python 的术语叫 Tuple）。

有了这些高层次的封装，你写起代码来，就特别滴简单、特别滴爽。比如，在 Python 中要把一个 List 翻倍，只需这么写：

```python

[1,2,3] * 2

```

就得到

```python

[1,2,3,1,2,3]

```

## 更少的代码量

得益于高层次的封装，在完成相同功能的前提下，脚本语言的代码量会比编译型语言少很多。

比如说，要打印出某个文本文件的内容，如果用 Java 实现，正常的写法大概要七、八行代码（把所有代码硬挤到一行的，不予讨论）；用 Python 也就三、五行。

再比如说，抓取某个网址对应的 web 网页，用 Python 自带的标准库实现，大概3到5行代码；但如果用 C++ 实现，代码量会增加许多（具体要写多少代码，取决于你用了哪个 http 的库）。

代码量少了之后，至少你看代码的时候（无论是看自个儿滴还是看别人滴），能少敲很多次翻页键，大大延长了键盘的寿命，顺便降低了手指头的劳损。

## 更好的可读性

当然啦，延长键盘寿命还不是关键，关键在于——代码量少了之后，（通常情况下）会有助于提高可读性。而可读性恰恰是 Python 的强项之一。

比方说：Python 在【语法层面】强制约定了作用域缩进（这是俺很喜欢 Python 的地方之一）。如此一来，即便是新手程序猿写出的 Python 代码，缩进风格也很统一。反观 C/C++/Java 的新手，写出的代码就没有这么整齐了。

## 更平缓的学习曲线

通常，脚本语言的语法都比较简单、傻瓜化。因此，入门也就容易很多。稍微有一些编程基础的人，就能够在短时间内上手。

比如俺手下的 C++、Java 程序员，以及某些测试人员，都可以在一周内（程序员用不着一周，一般就1、2天）掌握 Python 的语法并用来写一些辅助的小工具。大大节约了俺培训的口水。

## 支持“交互式”

很多脚本语言的 IDE 支持【交互式写代码】。也就是说，你每写完一行代码，解释器就执行一把。这样能很快发现输入错误，而且还可以立即看到执行结果。

# 脚本语言有啥缺点？<a name="cons"></a>

前面说了那么多优点，那脚本语言有啥缺点捏？

主要的缺点就是【性能差】。这是他们为上述优点所付出的沉重代价。所幸当今的计算机硬件突飞猛进，性能差的缺点已经越来越不明显了。

# Python 和其它脚本语言的比较<a name="compare"></a>

有同学可能要问了，脚本语言有很多，为啥俺独独青睐 Python 捏？

为了回答这个问题，下面俺拿 Python 和一些常见的脚本语言作一些【肤浅的】比较。

鉴于后面的内容极易引发语言的口水战，俺特此声明：虽然接下来会提及某些语言相对于 python 的缺点，但俺绝无贬低这些语言的企图，也无意证明 python 比这些语言优秀！俺只是陈述一下：当年是如何在几种脚本语言中进行取舍的？

除了 Python 之外，常见的脚本语言还有很多，比如：PHP、JavaScript（以下简称 JS）、Perl、VBScript（以下简称 VBS）、Ruby、Bash、Lua、Tcl（可别误以为是某家电厂商）......Python 是如何从这些脚本语言中脱颖而出的捏？俺挑选的时候，主要考虑了如下几点：

## 通用性（跨领域）

因为俺懒得学太多编程语言。所以，俺希望熟悉一门脚本语言之后，能够尽量多帮俺搞定不同领域的事儿。从这点来看，俺就不会选择 PHP（太偏重于 Web 服务端）、JS（太偏重于 Web 客户端）、诸如 Bash 之类的 Shell 脚本（太偏重于系统管理）。

而 Python 则属于通用的脚本语言，覆盖范围很广。比如 Web 开发、桌面 GUI 应用、系统管理、网络应用、科学计算等许多领域，Python 都可以轻易搞定。

## 人气够旺

关于“人气”的重要性，俺在《如何选择开源项目》一文中，有介绍过。人气越高、越流行，就意味着更多的资源（包括文档、相关软件），当你碰到问题需要解决，也有更多的人可以咨询。

关于编程语言的流行程度，可以大致参考 TIOBE 的排名（虽然 TIOBE 不能全面反映流行程度，但至少可作为某种参考）。

像 Tcl、PowerShell、Groovy、JavaFX 等都排在３０名之外（截至写本文的2009年8月），感觉用的人太少了，俺暂时不予考虑。而 Python 最近几年的排名则一路上升（请看“这里”），截止到2009年8月，已经高踞排行榜第６位。Perl 虽然也身居高位，但是最近几年的排名一路下滑（请看“[这里](http://www.tiobe.com/content/paperinfo/tpci/Perl.html)”）。俺个人认为，其人气不容乐观。

## 功能够强、库够丰富

另一个俺很看重的地方是功能是否够强大。在这点上，Python 和 Perl 都算是比较强悍的。关于 Python 如何强悍，俺会在本系列的第5篇帖子《作为瑞士军刀的 Python》中加以介绍。

反观 JS、Ruby、Tcl 等语言，则稍显不足（当然，也有可能俺孤陋寡闻）。

## 跨平台

由于俺平时会使用不同的操作系统，再加上俺负责的产品也是跨平台的。所以，俺对脚本语言有跨平台的要求。说到跨平台，诸如VBS、Bash之流就不予考虑了。

其实，很多脚本语言都支持跨平台。而 Python 在这方面，更为出众。不光支持主流的操作系统，还支持一些冷门的（比如古老的 DOS），还支持手持设备（比如智能手机和平板）。

## 和其它语言的整合、交互

最后这一点，估计大多数同学不会太关心。俺因为要在公司的产品中引入脚本技术，所以俺还得考虑该脚本语言和其它语言的整合能力。整合能力强的脚本语言，可以作为复杂系统中的胶水，用来把不同模块粘合在一起（关于 Glue Language，可以参见“[这里](https://en.wikipedia.org/wiki/Glue_language)”）。

在这方面，Python 和 Ruby 的表现都不错：

它们和 Java 的整合有Jython、JRuby；

和 dotNet 平台的整合有IronPython、IronRuby。

至于俺常用的 C++，Python 整合得比 Ruby 好。比如 C++ 社区大名鼎鼎的 Boost 库里面，就内置了一个 Boost.Python 的子库（参见“这里”）。

关于 Python 如何用作胶水，俺会在后续的帖子“作为胶合语言的 Python”中会详细介绍。

# 总结<a name="summary"></a>

基于上述几个方面的考虑，俺最终选择了 Python 作为日常使用的脚本工具，并把它引入到公司的产品中，作为模块之间的胶合剂。

啰嗦完Python作为脚本语言的方方面面，下一个帖子，咱来聊一下它作为动态语言的那些事儿。


[回到本系列的目录](RP-why-choose-python-0-overview)

> *版权声明* 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html">https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html</a>

.py | 转载：为什么俺推荐 Python[1]·作为脚本语言的 Python

### 文章目录

* [动态语言扫盲](#overview)
* [为啥要学习动态语言？](#whyDynamic)
* [为什么是 Python？](#whyPython)
* [总结](#summary)

上一篇帖子介绍了脚本语言的优缺点，然后又拿 Python 和其它脚本语言PK了一下。今天主要是忽悠一下动态语言，捎带忽悠一下 Python。如果你看完本贴，觉得动态语言不错，那俺建议你从 Python 开始入手。

# 动态语言扫盲<a name="overview"></a>

考虑到还有很多同学对动态语言了解不深入，有必要先来普及一下它的基本常识。已经了解的同学，请略过本节。

通俗地说：能够在运行时修改自身程序结构的语言，就属于动态语言。那怎样才算是“运行时修改自身程序结构”捏？比如下面这几个例子都 算：在【运行时】给某个类增加成员函数及成员变量；在【运行时】改变某个类的父类；在【运行时】创建出某个函数......

从这些例子，你应该对动态语言有一个初步的感觉了吧？毕竟传统的静态语言（比如C、C++、Java），是很难达到这些效果滴。

另外，有个误区需要澄清一下。很多同学以为脚本语言也就是动态语言。其实两者是不等价滴——虽然两者有很大的交集。比如 C# 在4.0之后，就可以算是动态语言了，但它不能算是脚本语言；另外，有很多 Shell 脚本语言（比如 DOS & Windows 下的 bat），不能算是动态语言。

关于动态语言更深入的介绍，大伙儿可以看“这里”。

# 为啥要学习动态语言？<a name="whyDynamic"></a>

扫盲之后，就该来说一下，学习动态语言的动机了。搞明白动机，学起来才有干劲嘛 :-)

## 顺应大趋势

假如你经常关注 TIOBE 的排名，那你应该能察觉出来，动态语言近两年的发展势头比较迅猛（在 Top10 里面，至少占了半壁江山）。这能从某个侧面反映出动态语言的影响力在扩大。

假使你不相信 TIOBE 的排名，俺再举一个例子。两大开发阵营（Java 和 dotNet）最近几年也加大了对动态语言的支持力度。比如，dotNet 的 CLR 加入了对IronPython 和 IronRuby 的支持；Sun 当然也不甘示弱，JVM 也开始支持 Groovy，JRuby 等语言。

俺费了这许多口水，列位看官应该明白动态语言是大势所趋吧。在这动态语言大行其道的日子里，你如果连一门动态语言都没搞懂，那出门都不好意思跟人打招呼。

不过，话又说回来，静态语言也是不会消亡滴。毕竟，静态语言有自己的优势（比如严谨、性能）。长期来说，必定是动态语言和静态语言并存。各自弥补对方的缺点。

## 了解新思维、新理念

学习一门动态语言还有一个好处：有很多时候，多学习一门语言，并不一定是为了在工作中用它，而是为了学习新的思维方式、体会新的理念。比如俺就曾经花时间去看 Prolog，但是俺在工作中，从来不需要用到它。（以后有空的话，俺会介绍一下这玩意儿）

由于动态语言可以在运行时修改自身结构，因此就会产生很多静态语言所没有编程范式和手法（比如 eval、Mixin）。如果你以前只使用静态语言，那你在学习了动态语言之后，多半会从它身上领略到很多新的思想和理念。

（关于 eval 的招数，俺后来写了一篇《再举几个动态语言 eval 手法的例子》）

## 能够化繁为简

可能有些同学觉得，前面说的都有些务虚，那咱再来说点具体实在的。大牛 Edsger Dijkstra（图灵奖得主）曾经说过：编程的艺术就是处理复杂性的艺术。咱们来看看，动态语言是如何处理复杂问题滴。

假设要你实现一个函数，用来完成两个数的“某种运算”，具体的运算类型作为函数的参数传入，然后该函数返回运算结果。比如：

```python

Foo("+", 2, 4) # 返回 6
Foo("*", 3, 5) # 返回 15

```

对于上述需求，你会如何实现捏？

请先暗自盘算一柱香的功夫，然后再往下看。

．．．．．．

Ｔｈｉｎｋｉｎｇ

．．．．．．

如果你用静态语言（比如 C、C++、Java）来实现，你可能会在函数内使用一个 switch，根据不同的运算符，进行计算，然后返回计算结果。

对于某些比较 ＯＯ 的语言（例如 C++、Java），你或许还会抽象出一个运算的接口类（纯虚类），然后分别派生出若干个不同的计算类（比如加法类、乘法类），看起来似乎比 switch 要优雅一些。

当然，用静态语言还有其它一些玩法，但是代码量都不会少。具体详情可以看很早以前的一个老故事：《4个程序员的一天》。（其实俺这个例子的灵感就是从那个老故事剽窃滴）

现在，咱们来看看 Python 是如何【优雅地】实现该需求滴。用 Python 只需要【两行代码】即可。请看：

```python

def Foo(op, n1, n2) :
 return eval( "%d %s %d" % (n1, op, n2) )

```

不懂 Python 的同学可能要问了，这两行代码是啥子意思呀？

其实，第一行代码只不过是定义了一个函数头，第2行代码才是精华。这里面利用了动态语言常见的 eval 手法（具体参见“这里”）。在 python 里面，内置的 eval 函数可以把某个字符串当成一个表达式，并对其求值。而语句 "%d %s %d" % (n1, op, n2) 只不过格式化出一个表达式的字符串。

顺便再插一句，Python 还有一个 exec 的内置函数，可以把一段 Python 源代码作为字符串参数传递给它，让该函数去执行。两个函数结合起来，就能玩出很多花样。具体的花样可以参见“这篇博文”。

# 为什么是 Python？<a name="whyPython"></a>

说了动态语言的种种好话，有同学会问了，动态语言有很多种，为啥非要学习 Python 捏？

首先，俺在本系列的第1篇帖子，已经对比过 Python 和另外几种脚本语言。那几种“脚本语言”碰巧也是知名的“动态语言”。Python 相对于他们的优势，此处就不再重复啰嗦了。

其次，单就语法本身而言，Python 的语法对动态性的支持是很优雅、很简洁滴。通过刚才那个 eval 小例子，大伙应该已经看出来了。为了更形象一点，咱拿前面提到的 Mixin 来 Show 一下 Python 的语法是如何的简洁。

通俗地说，Mixin 手法需要在【运行时】给某个类增加基类（也就是父类）。对于 Python 而言，每一个类都有一个内置属性 __bases__，里面包含这个类【当前】的所有基类。假如要在【运行时】增加基类，只需操作 __bases__ 这个属性即可。

比如有一个类 A 和类 B。如果要在运行时把 B 加为 A 的父类，可以用如下语句：
A.__bases__ += (B,)

是不是也很简洁，而且可读性也不差？相比而言，有些动态语言（比如 JavaScript），要实现类似的效果，代码就相对复杂了。

由于 Mixin 不是今天的重点，就不再深入展开了。


# 总结<a name="summary"></a>


最后，来个总结发言：如果你之前没有接触过动态语言，建议去学习一下；如果你已经打定主意要学，Python 是比较好的候选者。

好了，今天就聊到这里。下一个帖子，咱们来讲讲 Python 作为一个纯粹的面向对象语言，有些啥特色。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> [ https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html ](https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html)

.py | 转载：为什么俺推荐 Python[2]·作为动态语言的 Python

### 文章目录

* [抽象（Abstraction）](#abstract)
* [封装（Encapsulation）](#encap)
* [继承（Inheritance）](#inherit)
* [多态（Polymorphism）](#poly)
* [结尾](#summary)

本系列已经中断了很长时间 :( 直到最近一个读者来信问俺，为啥不继续写，俺才突然想起这个被遗忘的系列，实在是抱歉！前一个帖子介绍了作为动态语言的 Python，今天来聊一聊 Python 在面向对象编程（OOP）方面的特色。

本文主要针对那些熟悉 OOP，但还不熟悉 Python 的同学。为了让大伙儿有一个直观的认识，俺会拿 C++/Java 来进行语法上的对比。（这俩语言的名气够大，且号称支持 OO，也算有些可比性）

强调一下：本文虽然拿了某些语言来作对比，但丝毫没有贬低这些语言的意思，请这些语言的粉丝们，不要对号入座 :)

# 抽象（Abstraction）<a name="abstract"></a>

但凡介绍 OOP，自然会提到抽象。因为抽象，是 OO 的第一要素，也是其它要素的基础。而提到抽象，又不免提到对象（Object）。所以，俺首先来聊一下，Python 语言是如何体现“对象”这个思想的。

## Python的对象

如果要问俺，什么是 Python 中的对象，还真不好下一个严密又通俗易懂的定义。为了敷衍大伙儿，俺只好用一句话来概括，那就是 Python 语言中，【一切皆对象】。这句话该如何理解捏？简单来说，就是你在 Python 语言中涉及到的各种东东，都是“对象”。比如，函数是对象、各种数值（比如整数值、浮点数值、布尔值）是对象、模块（类似于 Java 的 package）是对象、None（类似于 Java 的空引用 null、C++ 的空指针 NULL）也是对象、甚至连类（class）也是对象......

对比一下 C++ 和 Java 的语法：只有【类的实例】才能算得上是对象。这2个语言的基本类型（比如“int、char、float”等）不是对象，至于函数，就更算不上了。

既然是一切皆对象，俺有必要稍微总结一下，Python 对象的共性，否则初学 Python 的同学还是会一头雾水。

## 对象的属性

首先，所有的 Python 的对象，都具有若干个属性。你可以通过内置的 dir() 函数进行反射，从而了解到某个对象分别都包含哪些属性。熟悉 Java 的同学，应该明白啥是“反射”。光懂 C/C++ 的同学，如果理解上有困难，可以先参考“维基百科的解释”。

另外，Python 还提供了若干内置的函数，用于在【运行时】操作指定对象的属性。具体如下：

```python

hasattr(obj, name) #判断obj对象是否具有名为name的属性
setattr(obj, name, value) #设置obj对象的名为name的属性值为value
getattr(obj, name) #获取obj对象的名为name的属性值
delattr(obj, name) #删除obj对象的名为name的属性

```

## 对象的类型

所有的 Python 对象，都可以通过内置的 type() 函数获取该对象的类型。这实际上就是 Python 的 RTTI 机制的体现。懂 C++ 的同学，可以回忆一下 C++ 的 typeid 关键字；懂 Java 的同学，可以想一想 Java 的 instanceof 关键字。

## 对象的标示

所有的 Python 对象，都可以通过内置的 id() 函数获取该对象的【唯一】标示。而且当一个对象创建之后，这个唯一标示就会始终保持不变。对于学过 C/C++ 的同学，不妨把这个“唯一标示”想象成该对象在内存的地址。这或许有助于你的理解 :)

Python 对象还有其它一些共性，考虑到本文的扫盲性质，就不再费口水了。有兴趣的同学，可以自己找些入门书研读一番。

## 【一切皆对象】的好处？

可能有同学会问，“一切皆对象”有啥好处捏？俺窃以为：当一切皆为对象，就可以把很多概念、操作、惯用手法统一起来，在语法层面体现出美感。

下面俺举几个例子，并拿 Java 来对比一下。

在 Java 里面，由于基本类型不是继承自 Object 类，引出不少麻烦。当初 Java 它爹刚开始设计容器类（比如 Vector、ArrayList ...）的时候，颇费了一番功夫。因为容器里面放置的东东必须是 Object，为了让容器能适应基本类型，只好给每一种基本类型分别对应一个派生自 Object 的包装类（Integer 类对应 int、Float 类对应 float ...）；后来又平添了自动装箱/拆箱的概念；搞来稿去，产生了 N 多复杂性。

而 Python 就没有这方面的困扰。

再拿刚才提及的“反射”来说事儿。虽然 Java 语言支持对象的反射，但是 Java 的 package 不是 Object，所以也就无法对 package 进行反射。反观 Python，任何一个 module（相当于 Java 的 package）import 之后，都可以直接通过前面提到的 dir() 函数进行反射，得知该 module 包含了哪些东东。仅仅需要2行代码：

```python

import xxx
dir(xxx)

```

# 封装（Encapsulation）<a name="encap"></a>

为了避免歧义，首先要明确一下：什么是“封装”？为了叙述方便，俺把【OOP 的封装】，分为“狭义”和“广义”两种。（关于“封装”的深入讨论，可以参见“另一篇博文”）

## 广义封装

OOP 很强调以数据为中心。所以 OOP 的广义封装，就是把数据和操作数据的行为，打包到一起。比如 C++/Java 里的 class，可以同时包含数据成员和函数成员，就算是满足“广义的封装”了。对于 Python 而言，其 class 关键字类似于 C++ 和 Java，也已经具有“广义的封装性”了。

## 狭义封装

而 OOP 的狭义封装，则更进一步，增加了信息隐藏（Information Hiding）。比如 C++ 和 Java 的“public、protected、private”等关键字，就是通过访问控制来达到信息隐藏的效果。Python 虽然没有针对访问控制的关键字来修饰类成员，但是 Python 采用了另外一套机制——根据命名来约定。在 Python 的对象中，如果某个属性以双下划线开头来命名（比如 __name），就能起到类似于 C++/Java 的 private 关键字的效果。

## 对访问控制的偏见

俺曾经在某技术论坛看到有人质疑 Python 的访问控制机制，说 Python 的私有属性，可以通过反射机制绕过，因此形同虚设。在此，俺想举 C++ 和 Java 来进行反驳。

在 Java 中，同样可以通过反射机制，来访问类的私有成员。至于 C++，得益于指针的强大，只要能访问某个对象（的 this 指针），通过计算该对象成员变量在内存中的偏移，一样可轻易对私有成员变量进行读写。虽然这么干挺变态滴，但技术上是可行滴。

# 继承（Inheritance）<a name="inherit"></a>

紧接着，咱再来说一下继承的话题。

## Python 的继承

Python 没有像 Java 那样，区分出“类继承”（OO 的术语中也叫“实现继承”）和“接口继承”；也没有像 C++ 那样，区分出“公有继承、私有继承、保护继承”这么花哨的玩意儿。Python 就只有一种继承方式。

## 继承的语法

Python 的继承语法，相比 C++/Java 而言，更加简洁。比如子类 Child 需要继承父类 Parent，代码只需如下：

```python

class Child(Parent) :
 # xxxx

```

如果是多继承，代码大同小异：

```python

class Child(Parent1, Parent2, Parent3) :
 # xxxx

```

假如你想知道某个类有哪些父类（基类），只需要通过 Child.__bases__ 便可知晓。

## 继承的动态性

其实上一个帖子已经介绍了动态改变继承关系的例子。但是考虑到上一个帖子年代久远（距本文将近1年），想必很多同学没看过或者看过又忘了。俺不妨再啰嗦一下：作为一种动态语言，Python 可以在【运行时】修改类的继承关系。这个特性比较酷，是 C++/Java 所望尘莫及滴。请看下面的例子：

```python

class Parent1 :
 def dump(self) :
 print("parent1")

class Parent2 :
 def dump(self) :
 print("parent2")

class Child :
 def dump(self) :
 print("child")

print(Child.__bases__)
Child.__bases__ += (Parent1, Parent2) # 动态追加了2个父类
print(Child.__bases__) # 此处打印出的父类信息中，已经包含 Parent1、Parent2

```

# 多态（Polymorphism）<a name="poly"></a>

至于 Python 的多态，和传统的 OO 语言差不多，似乎没有太多值得说道的地方。俺简单举个代码作例子。为了省打字，直接复用上述的3个类，并增加一个 test() 函数如下：

```python

def test(obj) :
 obj.dump()

```

然后对 test() 函数分别传入不同的类型的对象，输出结果俺就无需多说了吧？

```python

c = Child()
test(c) # 打印出 child
p1 = Parent1()
test(p1) # 打印出 parent1

```

# 结尾<a name="summary"></a>

今天的话题，主要是让不熟悉 Python 的网友，对 Python 在面向对象方面的特性，有一个粗浅、感性的认识。聊完了 OOP，下一个帖子会聊一下关于 FP（函数式编程）的话题。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，原作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址: 
> [https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)

.py | 转载：为什么俺推荐 Python[3]·作为面向对象语言的 Python

### 文章目录

* 什么是函数式编程
* FP 的特点
* FP 的优点
* Python 的函数语法
* 和 FP 相关的内置函数
* 消除控制流
* List Comprehension
* 闭包
* 结尾

春节前看到热心读者留言，提醒俺：Python 系列好久没更新了（不知不觉又过了一年多）。俺当时回复说：春节假期补上后一篇。昨天听到鞭炮声才发觉元宵已经到了，赶忙写出本文。

前一个帖子介绍了 Python 作为“面向对象编程”（以下简称 OOP）语言的特点，今天来聊一聊 Python 作为“函数式编程”（以下简称 FP）语言的特点。考虑到本系列面向的是 Python 的门外汉或刚入门的新手，故本文仅介绍若干浅显的 FP 特性。

# 什么是函数式编程

说实话，“函数式编程语言”是一个很大的话题。由于篇幅有限，本文不可能对这个话题做全面介绍。俺干脆偷一下懒，只简单说说。

从字面上看，所谓的函数式编程，就是以“函数”为中心的“编程范式”。估计有同学又会问了，啥是“编程范式”捏？哎呦，这又是一个很大的话题。通俗来讲，“编程范式”就是指编程的套路。比方说大家很熟悉的 OOP，就是一种“编程范式”。FP 跟 OOP 一样，都是一种编程的套路。做个简单类比：OOP 以“对象/类”作为程序设计的核心，而 FP 以“函数”作为程序设计的核心。

# FP的特点

既然说到 FP，自然要稍微说一下 FP 的特色。

## 函数很牛X

刚才说了，FP 是以函数为中心。既然如此，在支持 FP 的语言中，函数的功能自然十分牛X。通俗地说，OOP 语言中，类/对象能干的事情，FP 语言中的函数也能干。下面做一些对比，以加深大伙儿的印象。

OOP 中，对象可以互相赋值；FP 中，函数可以互相赋值。

OOP 中，对象可以作为函数的参数/返回值，FP 中，函数可以作为函数的参数/返回值。

某些 OOP 中，类可以嵌套定义；FP 中，函数可以嵌套定义。

某些 OOP 中，可以有匿名类；FP 中，可以有匿名函数。

## 避免副作用

在 FP 中，特别强调函数不要有“副作用”（洋文叫“side effect”）。没有副作用的函数，又称之为纯函数（pure function）。其输出完全依赖于输入。换句话说，只要输入一样，输出就一样。

要成为纯函数，函数内部不能读写函数外部变量、不能有设备 I/O（比如读写文件）......

无副作用是 FP 的重要特性。FP的很多优点来自于此特性。

## 避免控制流

在 FP 中，尽量避免用控制流语句（循环语句、判断语句）。对于控制流语句，FP 有另外的替代方式。比如：常用递归或高阶函数来替代循环。如此一来，FP 的代码会显得更简洁，更可读。

## 多态

大部分支持 FP 的语言，也都支持多态。函数参数支持多态化，便可实现非常灵活的功能。

说了这么多，不知道大伙儿明白了没？还是没整明白的同学，请看维基百科的英文词条（中文词条太简单，看不明白滴）。

洋文实在看不下去吗？那不妨看看 IT 大牛 Joel 写的《你的编程语言能这样做吗？》（中文版在“这里”）。此文以 JavaScript 来阐述 FP 的妙处。

# FP 的优点

再稍微说一下 FP 的好处，以强化大伙儿学习的动力。

## 模块化

在 FP 的思想中，函数最好是“纯”的，而且最好只完成“单一”的任务。在这种指导思想下，函数的模块化程度自然就高。

## 可复用性

模块化程度高，直接的好处就是可复用性好。

## 可读性

刚才说了，FP 的思想强调函数又纯又小。这样的函数，代码的可读性自然好，修改起来也方便。

## 易于调试

前面提到了纯函数。如果你的程序中大部分函数都是纯函数，则调试 Bug 会容易很多。像 OOP 中，类的多个成员函数都可以修改类的成员变量，有时候会导致调试极其困难。而纯函数没有此问题。

另外，多线程是调试的一大噩梦。当年俺还专门写过帖子，介绍 C++ 多线程的注意事项（在“这里”）。而纯函数由于没有副作用，不必担心各种“互斥”、“死锁”等问题。

## 易于测试

除了易于调试，纯函数的输出仅仅依赖于输入，这一特点注定了它很容易进行单元测试。

## 适合并行

在 FP 中，由于纯函数无副作用，很适合编写并行处理的代码。最典型并且在工业界获得巨大成功的例子就是 Erlang。

## 其它

当然啦，FP 的好处远不止上述这些（比如还有：利于形式化证明）。限于篇幅，俺就不展开了。

# Python 的函数语法

Python 中，常见的函数定义和函数调用，想必各位都晓得了。下面说几种不太常见的，且跟 FP 有关的语法。

## 函数赋值

Python 可以把函数直接赋值给一个变量。举例如下：

```python

def square(n) : # 这是一个计算平方的小函数，后面会反复用它举例
 return n ** 2

f = square # 此处赋值给变量 f
f(10) # 此处返回100。注意：对该变量使用小括号，等同于调用函数

```

## 匿名定义

Python 可以用 lambda 关键字定义【单行】的匿名函数。套用刚才的例子

```python

square = lambda x : x**2 # 定义一个单参数的匿名函数，并把该函数赋值给变量
square(10) # 此处返回 100

```

## 嵌套定义

Python 支持函数的嵌套定义（请看如下例子）。这种语法，在“闭包”中经常出现（后面会具体介绍“闭包”）。

```python

def outer() : # 外层函数
 s = "hello"
 def inner() : # 内层函数
 print(s) # 此处引用的是外层作用域的变量

 inner() # 输出 hello
 s = "world"
 inner() # 输出 world

```

# 和 FP 相关的内置函数

Python 内置了一大坨用于 FP 的函数，以方便程序猿写出简洁的代码。在接下去聊之前，俺有必要先介绍其中的2个。

## map(func, iter)

为了省事，俺只介绍2参数的 map（正宗的 map 支持 N 参数）。

参数 func 是个函数，参数 iter 是个迭代器（也可以理解为集合）

map() 会把 iter 的每个元素传给 func，并把每次调用的结果保存到一个 list 中，然后返回此 list。

举例：

挨个计算整数 list 的平方：

```python

map(square, [1, 2, 3]) # 返回 [1, 4, 9]

```

## filter(func, iter)

参数含义同 map

filter() 会把 iter 的每个元素传给 func，如果 func 返回结果为 True，就把元素保存在一个 list 中，最后返回此 list。

举例：

要过滤出所有奇数，代码如下：

```python

def odd(n) :
 return (n%2) == 1

filter(odd, [1, 2, 3]) # 返回[1, 3]

```

此处可以用上 lambda，把代码简化为一行：

```python
filter(lambda n: (n%2)==1, lst)
```

# 消除控制流

为了让大伙儿更深刻体会 FP 风格同传统风格的差别，俺把刚才两个例子组合一下——要求返回整数list 中所有奇数的平方。

传统的写法（有控制流）：

```python

def func1(old_lst) :
 new_lst = []
 for n in old_lst :
 if odd(n) :
 new_lst.append(square(n))
 return new_lst

```

FP 的写法（无控制流）：

```python

def func2(lst) :
 return map(square, filter(odd, lst))

```

怎么样？是不是更简洁？连 for / if 这两个关键字都不需要了。

# List Comprehension

这个洋文比较难翻译。有人叫做“列表推导”，也有人称为“列表展开”或“列表解析”。（俺比较喜欢头一个翻译——不禁让人联想到“推倒”:）

在 Python 中，这是一个很好吃的语法糖——可以让你写出很简洁、很优雅的代码。

举例1：

还拿刚才过滤奇数的例子。

```python

filter(lambda n: (n%2)==1, lst)

```

上述写法可以等价替换为列表推导：

```python

[n for n in lst if (n%2)==1]

```

举例2：
　　
再来一个稍微复杂的例子。假设有两个整数 list，分别存储矩形的宽度和高度。现在想把所有的宽度和高度进行两两组合，把大于 10 的面积打印出来。
　　
传统的写法（2层循环，4行代码）

```python

for w in width :
 for h in height :
 if w*h > 10 :
 print(w*h)

```

FP 的写法（无循环，1行代码，多精致啊）

```python

print( [w*h for w in width for h in height if w*h > 10] )

```

除了列表推导，Python 中还有字典推导、集合推导等等。为了省点口水，暂且打住。

# 闭包

闭包，洋文叫“closure”，解释在“这里”。它是 FP 的常见手法。那闭包到底有啥用捏？俺举一个微积分中，函数求导的例子。（不懂微积分或者对高数有心理阴影的同学，别担心，请把注意力集中在代码上）

```python

def d(f) :
 def calc(x) :
 dx = 0.000001 # 表示无穷小的Δx
 return (f(x+dx) - f(x)) / dx # 计算斜率。注意，此处引用了外层作用域的变量 f
 return calc # 此处用函数作为返回值（也就是函数 f 的导数）

```

现在，假设要计算二次函数 f(x) = x2 + x + 1 的导数，只需如下代码：

```python

f = lambda x : x**2 + x + 1 # 先把二次函数用代码表达出来
f1 = d(f) # 这个f1 就是 f 的一阶导数啦。注意，导数依然是个函数

```

有了一阶导数，就可以很容易地计算该函数在某点的斜率

比如要计算 x=3 的斜率，只需：

```python

f1(3)

```

如果要想得到二阶导数（导数的导数），只需依样画葫芦（瞧这代码写得多优雅）

```python

f2 = d(f1)

```

看到这里，大伙儿不妨设想一下：如果不用 FP，改用 OOP，上述需求该如何实现？俺觉得吧，用 OOP 来求导，这代码写起来多半是又丑又臭。

# 结尾

今天聊了不少 FP 的语法特性，可惜还是没聊完。由于俺比较懒，而且怕写得太长没人看，所以一些高级话题（比如：迭代器、生成器、等），今天就不介绍了。假如列位看官对那些玩意儿感兴趣，再抽空单独写一帖。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> <a href="https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html">https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html</a>

.py | 转载：为什么俺推荐 Python[4]·作为函数式编程语言的 Python

> **文章目录**
>
> * 短小精悍
> * 功能强大之1——跟非常多的语言整合
> * 功能强大之2——既可以跨平台，又可以跟操作系统深度整合
> * 功能强大之3——具有很丰富的第三方模块


本系列几乎变成年度系列了——上一篇帖子是去年元宵节发的。这几天正值春节假期，赶紧抽空补上本系列新的一篇，免得大伙儿以为本系列“烂尾”了。

“瑞士军刀”，大伙儿应该很熟悉，俺就不解释了。拿“瑞士军刀”来比喻 Python 就是想说明：Python 不但短小精悍，而且功能强大。今天就来介绍一下 Python 的这两个特点（尤其是后者）。

# 短小精悍

## 轻量级的的代码

要吹嘘 Python 的轻量级，首先要吹嘘的，自然是它简洁的代码。为了让大伙儿有个初步的印象，举几个例子。

举例1

要得到100-200之间所有奇数的3次方，只需如下一行

```python

[x**3 for x in range(100, 200) if (x%2)==1]

```

举例2

如果要把上述结果拼成一个逗号分隔的字符串，还是只要一行

```python

','.join([str(x**3) for x in range(100, 200) if (x%2)==1])

```

举例3

可能有人觉得上面2个例子是小儿科，再来举一个稍微复杂点的。只需一行代码，即可实现网络扫描（用的是第三方的 Scapy 工具）。

```python

# 传统的 ping 扫描，基于 ICMP 协议
ans,unans = sr(IP(dst="192.168.1.1-254")/ICMP())
# 局域网扫描，基于 ARP 协议
ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst="192.168.1.0/24"), timeout=2)

```

## 轻量级的安装环境

比如 Python 的安装包只有十几兆，而 Java 的 JDK 安装包动辄接近100兆。

## 轻量级的运行环境

同样是运行一个“Hello World”，用 Python 写的进程，占用的内存会更小（相比大多数其它编程语言）。而且 Python 的运行环境（Python 虚拟机）可以很方便地嵌入到 C/C++ 程序中，只需额外带一个动态库即可。

# 功能强大之1——跟非常多的语言整合

很多程序员喜欢“在一棵树上吊死”——始终只用一种编程语言。俺非常反对这种倾向。要想成为一个优秀的程序员，有必要掌握【不同风格/不同范式】的编程语言。编程语言多样化的好处在于，你可以利用不同语言的特色，以取长补短。

而 Python 在跨语言整合方面，堪称佼佼者——你很难找到哪个语言，能像 Python 这样，跟如此多的语言进行整合。

下面简单举几个例子：

## 跟 C/C++ 整合

咱们常用的 Python 运行环境也称为 CPython，是用 C 语言写的。所以 Python 天生就具有跟 C/C++ 整合的能力。而且这种整合是双向的——也就是说，既可以在 Python 模块调用 C/C++ 模块，也可以在 C/C++ 模块调用 Python 模块。

Python 跟 C/C++ 整合，可以有如下三个优点：

1. 丰富的第三方资源

因为 C/C++ 具有非常丰富的第三方模块（包括开源和闭源），其丰富程度超过 Java。所以 Python 可以利用这种整合能力，直接调用各种 C/C++ 的模块，来丰富自己的功能。

举个例子

比如 cURL 是一个C语言编写的应用层网络工具，功能非常强。而 Python 可以通过整合 cURL 直接获得 cURL 的强大功能。

2. 性能的提升

除了第三方模块丰富，C/C++ 开发的模块还有一个优点——性能好。所以，Python 整合了 C/C++ 模块之后，还能趁机获得性能提升。

举个例子

比方说你要写一个 3D 游戏，其中的 3D 渲染引擎是性能瓶颈。那么你可以用 Python 整合一个 C/C++ 的 3D 渲染引擎。而 Python 只用来实现跟游戏高层应用逻辑相关的部分。这样可以一举两得：性能不差，代码不多。

顺便说一下：如今有不少游戏都走这个开发思路——底层引擎用【重型的】C 或 C++ 实现，以确保高性能；而高层的业务逻辑则用【轻型的】脚本语言来开发。

3. 跟操作系统整合

地球上的操作系统，只要是有点名气的，内核都是 C 语言写的；除了操作系统内核，大部分操作系统的运行库也都是 C/C++ 编写的。所以，Python 跟 C/C++ 整合，可以带来第三个好处——跟操作系统的整合。关于这点，待会儿俺还会专门聊。

## 跟 JVM（Java） 整合

通过 Jython 这个开源项目，Python 可以无缝整合到 JVM 环境中。如此一来，Python 能直接调用所有 JVM 标准库（比如 JDBC）和第三方库（比如 Lucene），还可以跟各种 JVM 语言（比如“Java、Scale、Groovy”等）进行互操作。

## 跟 dotNet 整合

通过 IronPython 这个开源项目，Python 可以无缝整合到 dotNet 环境中。如此一来，Python 能直接调用所有 dotNet 的标准库（比如 ADO.NET）和第三方库，还可以跟各种 dotNet 语言（比如“C#、F#”等）进行互操作。

顺便说一下：Jython 跟 IronPython 貌似同一个作者，牛人啊！

# 功能强大之2——既可以跨平台，又可以跟操作系统深度整合

## Python 语言如何体现“跨平台性”？

说到跨平台这个话题，俺给编程语言分一下类：

1. 可以跨平台，但无法跟操作系统深度耦合（比如 JavaScript、PHP）

2. 可以跟操作系统深度耦合，但无法跨平台（比如 VB、VBScript）

3. 既可以跨平台，又可以跟操作系统深度耦合（比如 C C++ Python）

为啥第三类语言能做到两者兼得？因为这类语言把选择权留给了程序猿——

一方面，如果程序猿遵循跨平台的开发规范，那么写出来的代码就是跨平台的；

另一方面，程序猿也可以写出跟系统耦合很紧密的代码——这样的代码虽然不能跨平台，但可以发挥特定平台的强项。

显然俺喜欢第三类编程语言，因为这类语言给了程序猿自由。

## Python 语言如何“与操作系统深度整合”？

Python 的跨平台特性，懂 Python 的同学估计都晓得了。所以俺单独说一下 Python 如何跟操作系统深度整合。为了照顾到大多数人，俺拿 Windows 来说事儿。

在 Python 社区有一个很有名气的库，叫做 PyWin32。通过这个库，可以让 Python 代码很容易地调用 Windows 的 API 以及 COM 组件。

比方说，可以用 Python 代码直接操作 Windows 注册表

比方说，可以用 Python 代码直接读写 Windows 的系统日志

比方说，可以用 Python 代码直接操作某个窗口句柄

比方说，可以利用 COM 组件，直接调用 Word 来处理 doc 格式的文档

......

# 功能强大之3——具有很丰富的第三方模块

最后一个方面，也是最重要的一个方面，就是 Python 社区具有非常非常丰富的资源（第三方库），而且几乎都是开源的。形形色色的编程领域几乎都可以看到 Python 的身影。

为了让众多程序员读者领略 Python 的丰富资源，俺特地整理了一个 wiki 页面（请用鼠标猛击“这里”），放上 Python 在各个编程领域的常用模块。为了显示出 Python 代码的简洁，某些模块还放上示例代码。

最后感叹一下：

写这篇博文只花了不到一小时，而整理这个 wiki 页面累计超过10个小时。不过这时间没白花——整理的时候顺便对某些领域有了更多的了解。这也就是写博客的好处，既可以帮助别人，又可以帮助自己。

大伙儿如果觉得俺整理的清单有遗漏，欢迎到本页面留言补充。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
>
> <a href="https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html">https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html</a>

.py | 转载：为什么俺推荐 Python[5]·作为瑞士军刀的 Python


2024 年 9 月 30 日起，本站网址
- 从 `https://mountaye.github.io/blog/` 
- 变更为 `https://blog.mountaye.com`.

因为网站仍然架设在 GitHub Pages 上，所以旧网址可以自动跳转到新网址。

但是下一步计划把网站迁移到 Cloudflare Pages 上，因为 Next.js 项目不同构建之间文件差异过多，不适合作为 git 仓库的内容进行托管。

所以无法保证将来旧网址依然可以自动跳转。请使用浏览器收藏功能的读者更新收藏夹，使用 RSS 订阅功能的读者更新 RSS 源。

根据初步计划，过渡期将持续到 2024 年 12 月 31 日。


通知：本站网址変更

.zh | 反派影评·波米：开局的终局

转载 | 《叙述》

·转载 | 吉汉：边缘化的六四论述：八九春夏，其实发生的是“两场运动” | 端传媒

.en | 外交政策杂志《中国在衰落，而这才是问题》及一篇反驳



> 2011 年 7 月 30 日，桥水基金的达里奥最近对滴滴中止赴美上市和中国整治课外辅导两件事发表了看法。大陆的很多财经自媒体对这篇文章进行了转述，但是并没有引用原文。周末读了一下，至少我对原文的理解，和财经自媒体所称达里奥的观点不同。所以翻译一下，供参考。
>
> 在找原文的过程中，还发现了一篇刊登于 2021 年 7 月 11 日日经亚洲板块的观点性文章，对达里奥的文章更早的一篇《不要对变化世界中的中国崛起视而不见》进行了反驳，遂将达里奥此文与反驳一并翻译，附于后。

## 0

> 2011 年 7 月 30 日，原文 [发表于 LinkedIn](https://www.linkedin.com/pulse/understanding-chinas-recent-moves-its-capital-markets-ray-dalio/)


最近中国与—— 1）滴滴的上市和对其数据使用的控制以及 2）中国教育公司正被转为非营利组织——有关的政策举措，让人对中国的资本主义和资本市场产生了很多怀疑，所以我想帮助澄清一下那里发生了什么事。 

我知道这让不了解正在发生的事情的人感到困惑。自从我36年前开始去中国以来，我发现大多数与政策制定者没有直接接触、没有详细了解变化趋势的西方观察家们，往往不相信中国共产党真的是在用资本市场促进发展。他们将最近这两个举措解释为共产党领导人显示了他们真正的反资本主义的，尽管过去 40 年来的趋势已经明显地朝向用资本市场发展市场经济，并在这个过程中让企业家和资本家变得富有。结果，他们误解了中国正在发生的事情，并且可能会继续误解。这一回，政策制定者向滴滴表示，进行上市可能不是最好的选择，政府很容易让人理解地希望处理数据隐私问题。就教育辅导公司而言，政府希望减少教育不平等，和那些急于让孩子获得这些服务但又负担不起的人的经济负担，通过广泛提供这些服务。他们认为，这些东西对国家更好，即使股东不喜欢。

我记得有许多类似的误解。例如，我记得中国散户投资者泡沫破灭导致政府购买股票，然后政府试图操纵市场一段时间。我还记得中国央行在 2015-16 年间因扩大 [汇率区间](https://www.investopedia.com/terms/c/currency-band.asp) 而导致人民币暴跌，以及这如何导致许多投资者将这些发展作为政策制定者正在远离发展中的资本市场的证据。一些持怀疑态度的投资者认为这些举措是不恰当的反自由市场的干预，尽管这些举措在许多资本主义市场已经多次发生，尽管美国和其他发达市场的财政和货币政策干预使中国政府对其市场的干预相形见绌. 通过它，所有中国决策者都成功地应对了影响并实现了他们的目标；即，他们的行动方向从未改变。这个方向就是支持稳定快速发展资本市场、企业家精神、对外国投资者的开放程度。所以我鼓励你看看趋势，不要误解和过度关注摆动。

要了解正在发生的事情，您需要了解中国是一个国家资本主义体制，这意味着国家运行资本主义，为了为大多数人的利益服务，政策制定者不会让资本市场的敏感性和富裕资本家，挡住他们认为最适合该国大多数人的道路。相反，资本市场中的人和资本家必须了解他们在体制中的从属地位，否则他们将承担自己错误的后果。例如，他们需要纠正认为自己的财富有权决定事情发展方向的错误。 

您还需要了解，在这个快速发展的资本市场环境中，中国监管机构正在探索适当的法规，因此，当法规变化迅速且不明确时，会导致此类混乱，这可能会被误解为反资本主义举措. 

此外，您需要了解全球地缘政治环境的变化会导致一些变化。你可以看到这反映在美国政府的政策转变上，例如 a) 改变对中国公司在美国上市的政策和 b) 威胁禁止美国养老基金在中国投资。 

假设这样的事情将来会发生，并以此为依据进行投资。但不要将这些波动误解为趋势的变化，也不要指望这种中国国有资本主义与西方资本主义完全一样。 

话虽如此，我确实认为不幸的是，中国的决策者没有更清楚地公开表达他们行动背后的原因。 

至于投资，在我看来，美国和中国的体制和市场都有机会和风险，很可能相互竞争，相互多元化。因此，它们都应该被视为一个人的投资组合的重要组成部分。我敦促您不要将此类举动误解为对过去几十年存在的趋势的逆转，并让它吓跑您。


## 1

> 达里奥 2020 年 10 月 23 日在 [《Financial Times》上的一个专栏](https://www.ft.com/content/8749b742-d3c9-41b4-910e-80e8693c36e6)，原文标题为 "Don’t be blind to China’s rise in a changing world".
>
> 原文有付费墙，译文基于 [这个连接](https://thefinanceinfo.com/2020/10/23/dont-be-blind-to-chinas-rise-in-a-changing-world/)

作者为桥水联合创始人、联席董事长兼联席首席投资官

从我记事起，人们就说中国不可能成功。共产主义行不通。威权主义行不通。中国人没有创造力。他们在坏账和房地产投机方面有很大的问题。然而，我们每天都看到中国以非凡的方式取得成功。

它实现了一些世界上最低的 Covid-19 病例率。在过去的一年里，其经济增长了近 5%，没有将债务货币化，而所有主要经济体都在收缩。中国的生产多于消费，国际收支顺差，与美国和许多西方国家不同。今年，全球近一半的首次公开募股将在中国进行，其中包括蚂蚁金服 300 亿美元的上市，这是全球有史以来规模最大的一次。甚至特斯拉最畅销的 Model 3 汽车也可能很快就会完全在中国制造。

世界秩序正在发生变化，但由于持续存在的反华偏见，许多人忽略了这一点。中国的非凡表现并不新鲜。事实上，除了1839-1949年的“百年屈辱”外，它在历史上一直是世界上最强大的国家和文化之一。就在过去的四年里，它的经济变化是显着的。无论你对中国的“国家资本主义”有什么批评，你都不能说它没有用，即使你强烈反对北京的做法。

36年前我第一次访问中国时，我会给高级官员10美元的袖珍计算器。他们认为它们是奇迹装置。现在中国在先进技术上与美国匹敌，并且可能会在五年内领先。自 1984 年以来，人均收入增长了 30 多倍，预期寿命增加了十年，贫困率几乎降至零。 1990年，中国第一个股票市场由我认识的七位爱国青年设计。从那时起，它已成为世界第二大。

所有这些都是在说，中国的崛起具有巨大的政治、经济和投资影响。在政治上，中国已成为美国两党面临的主要问题，美国担心中国崛起，扩大全球影响力，并且拒绝其威权模式和对待新疆维吾尔族穆斯林等少数民族的方式。中方的反驳是，维护秩序需要强有力的手，在其境内发生的事情是自己的事，美国有自己的人权问题。它对台湾、香港等地区的主权也是争议很大的大问题。没有人知道这些紧张局势将如何发展，但它们会影响我们所有人。

与此同时，中国的经济规模与美国大致相当，而且扩张速度更快——所以时间站在中国一边。它拥有不断增长的受过良好教育的人口，约占世界科技大学专业的三分之一，是美国的三倍。它还产生和收集更多数据以使用人工智能进行处理。对于西方的许多人来说，这在国家监视方面有阴暗面。但对许多中国人来说，它强化了积极的社会规范，同时也带来了巨大的效率。看待中国相对实力的一种方式是，在人口是美国四倍的情况下，当其人均收入在大约 25 年内达到美国的一半时，其经济规模将是美国的两倍。

最后，还有投资影响。作为一名全球宏观投资者，关于我应该在何处投资多少，查看基本面以及其他人的仓位，我考虑得很多。中国基本面强劲，资产定价相对有吸引力，全球都在减持中国股票和债券。这些目前占外国投资组合持有量的 3% 或更少；中性权重将接近 15%。

这种差异至少部分是由于反华偏见。我认为它即将改变。中国市场正在向外国人开放，他们现在至少可以进入其中的 60%，而 2015 年为 1%。主要指数的基准权重正在上升。因此，我预计中国将享受有利的资本流入，这将支持已经处于两年高位的货币和金融市场。所有这些都促使我在投资组合中增持了中国。

当然，任何国家都可能出现问题。北京可能不会坚持目前的经济改革进程，尽管我怀疑这会发生。美国和中国也在贸易、技术、地缘政治、资本市场和军事力量方面展开激烈竞争——有人说是交战。没有人知道这些战争会有多严重，哪个国家会获胜，或者如何获胜。这就是为什么我将资金分散到这两个国家。

从长远来看，永恒和普遍的真理决定了国家成功或失败的原因。简而言之，当帝国生产力高、财务状况良好、收入多于支出、资产增长快于负债时，帝国就会崛起。这种情况往往发生于他们的人民受过良好教育，努力工作时，并举止文明之时。 正如我在一项正在进行的研究中记录的那样，客观地将中国与美国在这些措施上进行比较，基本面显然有利于中国。

偏见和偏见总是让人们看不到机会。 所以，如果你因为与中国发生的事情不符的原因而对中国持怀疑态度，我建议你理清思路。 美国的事件及其在不断变化的世界中的地位也是如此。 美国大选前夕是反思两者的好时机。


## -1

> 日经亚洲板块对上文的 [一个反驳](https://asia.nikkei.com/Opinion/Why-Ray-Dalio-is-wrong-about-China)，作者是 Andrew Hunt 和 Ben Ashby，发布于 2021 年 7 月 11 日

*Andrew Hunt 是 Hunt Economics 的首席执行官，也是 Dresdner Asset Management 在亚洲的前顾问。Ben Ashby 是摩根大通首席投资办公室的前董事总经理。*

高盛与中国工商银行（ICBC）的新财富管理合资企业，和对冲基金亿万富翁Ray Dalio有什么共同点？他们都是希望更多地接触中国金融市场的全球金融投资者的一部分，因为他们认为中国的崛起是不可避免的。我们认为他们错了。

我们认为，达利欧在2020 年 10 月 23 日发表在《金融时报》上的专栏《不要对中国在不断变化的世界中的崛起视而不见》中提出的许多论点今天都可能被证明是错误的，而其他观点可能随着时间的推移也会被证明是错误的。中国市场很可能对外国人“开放”，但是否保证他们有更多的资本是另一回事。

乍一看，更多中国储蓄进入金融市场的前景似乎证明了这种兴奋是合理的，中国证券将成为全球投资者投资组合的更大一部分。

我们计算出，按当前汇率计算，至少需要 6 万亿美元的海外资产来重新平衡国内储户的存款密集型投资组合，使其分布类似于中国邻国的分布。而且，正如达利欧在英国《金融时报》中指出的那样，“世界正在减持中国股票和债券”，它们占外国投资组合的 3% 或更少，而不是接近 15% 的“自然”权重。

到目前为止，如此真实。但许多国际金融机构希望，金融部门政策的“正常化”、投资组合的重新平衡和持续的债务推动的增长将创造一笔横财，他们现在应该为自己建仓。这就是我们不同的地方：我们预计在可预见的未来不会发生任何根本性的变化，由于中国经济的现实。

该国的大部分家庭财富仍存留在银行账户中，而且对外流动受到严格控制。因此，银行体系庞大：中国在全球存款中所占的份额大约是其在全球国内生产总值中所占份额的两倍。

不过，中资银行的主要职能是促进政府政策，促进符合中国共产党原则的经济发展。他们必须确保关键部门有现成的廉价信贷供应，支持实现经济的产出最大化，而非利润。

自 1980 年代后期经济改革开始以来，这种模式必然助长了更广泛的企业部门的赤字。我们估计，平均短缺每年相当于 GDP 的 16%。这必然会影响贷款、储蓄和监管。

为支撑经济，抑制融资成本；在过去四十年的大部分时间里，实际利率一直为负。自然，不愿向借款人收取高额费用对储户来说意义更小。但是已经实施了严格的监管，严格控制资本流动，以确保他们将大部分财富留在银行。

如果中国政府考虑将其做法正常化，将面临艰难的选择。当局可以允许市场将资金分配给寻求利润最大化的公司，或者他们可以继续将资本引导到许多破坏股东价值的公司。在后一种情况下，投资者将不得不接受中国的金融市场没有真正的经济目的，长期回报可能会受到限制。

正如著名投资者本·格雷厄姆所说，“股市在短期内可能是一台投票机，但随着时间的推移，它是一台称重机。”

如果没有利润最大化的潜在驱动力，中国股票就很难达到投资者预期的回报。这意味着该国的储蓄者可能会与任何遵循 Dalio 的 GDP 称重方法的长期被动投资者一起失败——这一策略在 1990 年代后期的亚洲金融危机期间失败了。但企业行为的任何巨变都不符合政策制定者的经济目标。

如果允许更多的国内资金离开该国，也会出现困难局面。对储蓄市场的任何放松管制都可能将中国宝贵的外汇储备消耗到一个危险的低水平。

尽管这些储备的名义价值很大，但它们是否足以满足中国这样规模的经济体的需求仍然是一个悬而未决的问题。此外，如果储户要根据区域标准进行再平衡，我们认为银行系统将面临至少 180% 的贷存比，从而阻碍其向企业提供廉价信贷的主要功能。公司的融资成本也将飙升，引发大量重组，进一步损害投资者回报。

在可预见的未来，中国的银行和企业根本无法承受国内储蓄的流失。即使这些储蓄被锁在家里，前景也越来越消极。由于债务负担已经很高，经济放缓，加上多年不景气的贷款后不良贷款比例不断增加，中资银行将越来越挣扎，其发放新贷款的能力将下降。这在一定程度上解释了中国吸引更多外国投资者的动机。有希望的正常化和确保新的资本来源有助于推迟艰难的决定。

这一切都在达利欧几乎没有提到的实际考虑之前，例如将资金投入到一个有资本管制的国家或满足国内监管机构和投资者的需求的影响，特别是当他们越来越关注环境、社会和治理原则时，如以及应对日益激烈和紧张的地缘政治竞争。没有人知道这一切的正确风险溢价是多少。

在任何像中国这样规模的市场中，投资者都将有较早获得轻松获利的机会。鉴于对冲基金倾向于短期投资，Dalio 可能会获利。但我们认为潜在的回报最终会消退。

更糟糕的是，如果中国无法改革国内经济，或者国际政治局势进一步恶化，甚至撤资都可能成为问题。如果发生这种情况，仓促进入的投资者和公司将有时间悠闲地忏悔。


.en | 达里奥关于滴滴及课外辅导的看法，及2篇相关文章

> 本文的作者保罗·格雷厄姆是一位程序员、画家兼投资人。他曾在哈佛大学获得计算机方向的博士学位，也在罗德岛设计学院和佛罗伦萨绘画艺术学院学习过绘画。作为两种身份的结合，他创作了《Hackers & Painters》一书。作为投资人，他最为出名的成就是参与创办了创业孵化公司 Y Combinator. 
>
> 保罗在互联网上最有名的文章，当属这篇《How to Disagree》，他的个人维基百科词条上专门用一个小节介绍了这篇文章。网络上也有根据这篇文章制作的“反驳金字塔”图片。虽说一图胜千言，但是从文字转化为示意图的过程中，很多信息被省略，一些常见的话术和对这些话术的反驳，以及本文文末，对反对的不同层次，其意义的讨论和澄清，都没有出现在图中。在争论中直接扔给对方一张反驳金字塔的图，看起来反而很接近于最低层次的扣帽子。
>
> 以下是全文翻译。原文链接：[http://paulgraham.com/disagree.html](http://paulgraham.com/disagree.html)

作于 2008 年 3 月

网络正把写作变成对话。二十年前，作者只用写而读者只能读。网络让读者可以回应，而且这些回应越来越多——评论区里、论坛里，和他们自己的博客文章里。

这些回应的人中有很多是反对原文的。这是可以预见的。同意不如反对激励人们（发表看法）。当你同意的时候可说的也更少。你也许可以就作者说过的东西进行拓展，但是他可能已经把最有趣的推论都说完了。当你反对的时候，你所踏足的领域是他可能还没涉及到的。

结果就是，反对的声音要多得多，尤其是以字数来衡量。这并不意味着人们的戾气愈发严重。我们交流方式的结构性改变就足以解释这一现象了。但是尽管驱动着反对声音增多的并非愤怒，人们因为反对增多而变得更加生气的危险却真实存在。尤其是在网上，在你不用和对方面对面的地方发言是容易的。

如果我们都在越来越多地进行反对，那我们就需要把这件事小心做好。什么叫好好反对？绝大多数读者可以区分单纯的**扣帽子**和通过细致推理进行的反驳，但我认为把中间状态也逐个列举一下是很有帮助的。所以下面就是对反对的不同层次进行列举的一个尝试：

## 第 0 层：扣帽子 (Name-calling)

这是反对的最低层次，可能也是最常见的形式。我们都见过这样的评论：

> 你个娘炮！！！！！！

但是重要的是意识到，更加高大上的**扣帽子**同样没什么效力。一个像这样的评论：

> 作者是个自以为是的外行。

不过就是一个高配版的“你个娘炮”。

## 第 1 层：诉诸身份 (Ad Hominem)

**诉诸身份**的攻击不像单纯的**扣帽子**那么无力。它其实可能有些威力。比如说，如果一个参议院写文章说参议员们的工资需要提高，有人可能会回应道：

> 他当然会这么说了，他是个参议员。

这并不会反驳作者的论证，但是这至少和主题有关。然而，这仍然是一种很无力的反对。如果这位参议院的论证里有什么错误，你应该说明错在哪里；如果没错，他是一个参议员又有什么区别？

说作者不具备写作某一话题文章的权威性是**诉诸身份**的一个变种，而且是特别没用的一种，因为好的想法经常来自于旁观者。问题是作者对还是不对。如果他缺乏的权威性导致他犯了错误，请把这些错误指出来。如果没有，那（缺乏权威性）就不是一个问题。

## 第 2 层：诉诸语气 (Responding to Tone)

接下来这个层次我们开始看到针对内容而非作者的回应。这些回应中最低级的一种形式就是反对作者的语气。例如：

> 无法相信作者竟然用如此傲慢的方式贬低智能设计。

尽管强于攻击作者，这仍是一种无力的反对。作者是对还是错，比他的语气重要得多。尤其是鉴于语气是多么难以评判。一个挂着某种观点的粉丝牌子的人可能被一些其他人觉得正常的语气所激怒。

所以如果你对于一篇文章所能说的最坏的事情就是**诉诸语气**，那你实在是没说出什么东西来。作者是不是轻佻但是正确？那总好过持重但是错误。如果作者有哪里错了，那就指出到底是哪儿。

## 第 3 层：声明异见 (Contradiction)

这一层次我们终于来到了对说过的内容进行的回应，而不是怎么说的和谁说的。对一个论证的最低层次的回应就是简单陈述相反的论点，没有或只提供很少的支持性证据。

这一方法经常和第2层结合起来使用，正如：

> 无法相信作者竟然用如此傲慢的方式贬低智能设计。智能设计是合理的科学理论。

**声明异见**有时可能有些威力，有时仅仅让人看见明确声明的反方命题就足以看到反方是正确的。但是通常来说，证据是有帮助的。

## 第 4 层：证明异见 (Counterargument)

到了第4层上，我们终于见到了第一种有说服力的反对形式：**证明异见**。之前的几种形式通常可以因为啥也没论证而被忽略。**证明异见**可能会证明某些观点。问题在于，很难说证明的究竟是啥。

**证明异见**就是在**声明异见**之外，再加上论证和/或论据。当其针对的是原论点时，这种方式是令人信服的。但是不幸的是，通常情况下**证明异见**针对的是和原论点稍微有些区别的东西。多数情况下，争论得热火朝天的俩人其实争论的是两件不同的事情。有时他们甚至互相同意对方，但是陷于斗嘴的程度如此之深，以至于没有意识到这一点。

反对和作者原文有轻微不同的论点也是可能有合理原因的：当你感觉他们没有把握问题的中心的时候就可以这么做。但是当你这么做的时候，应该明确说明你在论证不同的论点。

## 第 5 层：驳斥对方 (Refutation)

最有说服力的反对形式是**驳斥对方**。它同样是最罕见的，因为需要最多的工作量。其实，反对的不同层次构成了一种金字塔，层次越高，你能找到的实例就越少。

要**驳斥**一个人，你可能得引用他们说过的话。你可能必须找到一件“还热乎着的凶器 (smoking gun)”，一个在你反对的内容中你认为搞错了的东西，然后解释它为什么错了。如果你找不到可以用来反对的实际引用，那么你可能在犯 [“稻草人谬误”](https://zh.wikipedia.org/wiki/%E7%A8%BB%E8%8D%89%E4%BA%BA%E8%AB%96%E8%AD%89)。

尽管**驳斥对方**一般包含引用，引用并不必然意味着**驳斥对方**。有些作者引用部分他们反对的文章的内容，做出合理**驳斥对方**的样子，然后用第 3 层甚至第 0 层的形式进行回应。

## 第 6 层：驳斥对方中心论点

**驳斥**的力度取决于你驳斥对方的是什么。最强有力的反对形式就是**驳斥对方的中心论点**。

即便到了第5层，我们偶尔仍能看见故意的智力不诚实 (interlectual dishonesty)，比如有人挑出一个论证中不重要的点然后把它们**驳斥**一番。有时这么做的精神让这种反对更像是一种处心积虑的**诉诸身份**的攻击，而非真正的**驳斥对方**。比如，纠正某人的语法，或者揪住名字或数字中的小错不放。除非反对的论证实际上依赖于这些错误，否则纠正它们的唯一目的就是损害对手的名誉。

> **intellectual-dishoesty**
>
> 相对于 intellectual honesty, 故意在辩论和推理中使用谬误被称作 intellectual dishonesty, 译作“智力不诚实”。详见维基百科 inteleectual honesty 词条。

真正意义上的**驳斥对方**要求一个人反驳其中心论点，或者至少是其中之一。那意味着一个人必须明确地指出中心论点是什么。所以一个真正有效的**驳斥对方**看起来就像：

> 作者的主要论点似乎是 X。正如他说的：
> 
> > <引用的内容>
> 
> 但这是错的，原因如下……

你引用并指出错误的内容不一定是原作者主要论点的原样陈述，只要批判的是中心论点所依赖的东西就足够了。

## 这样做的意义

现在我们有了给不同形式的反对进行分类的方法。这有什么好处？这种反对的分级所**不能**带给我们的，就是判断输赢的方法。反对的不同层次描述的只是一个反对的形式，而不是反对是否正确。一个第 6 层的回应可能仍然是完全错误的。

但是尽管反对的不同层次没有给一个回复的可信度设定一个下限，但它的确设定了一个上限。一个第 6 层的回应不一定有说服力，但是一个第 2 层的回应一定没有说服力。

区分不同形式反对的最明显的好处就是帮助人们评估他们所阅读的东西。特别是，这将帮助他们看清的议论。一个雄辩的演讲者或者作家可以给人一种碾压对手的印象，仅仅通过使用强有力的词汇。实际上这可能是一个煽动者的决定性特质。通过辨别不同形式的反对，我们给了批判性阅读者一个图钉，让他们能戳破这种气球。

这种标签同样能帮助写作者。大多数的智力不诚实是无意的。有些人用**诉诸语气**的方法批评他反对的观点，可能真的觉得自己言之有物。放大并看清他当时在反对分级上的位置，有可能会启发他尝试进步到**证明异见**和**驳斥对方**的层次上去。

但是好好反对的最大好处并不只是让对话变得更好，而是让被反对的人开心一点。如果你研究对话，会发现第 1 层比第 6 层更加刻薄。当你真的言之有物的时候，大可不必刻薄。实际上，你也不会想这么做。当你真的有观点要表达时，刻薄只能起阻碍作用。

如果沿着反对的不同层次向上攀登可以让人们不那么刻薄，那将会让大多数人更快乐。多数人并不乐于刻薄，他们这么做只是因为控制不当。

感谢 Trevor Blackwell 和 Jessica Livingston 阅读这篇文章的草稿。

.en | 翻译：保罗·格雷厄姆谈如何反对


> 人类的本质就是复读机。

首先萌狼看[phoenixlzx](https://blog.phoenixlzx.com/2014/03/10/browser-from-a-to-z/)那有一篇这样的文章，貌似很好玩的样子。

咱看[约伊兹的萌狼乡手札](https://blog.yoitsu.moe/a2z.html)那有一篇这样的文章，貌似很好玩的样子。

咱也试试看？

- __A__ [amazon.com](https://www.amazon.com): 美帝的JD
- __B__ [bilibili.com](https://www.bilibili.com): 比利比利♂干杯
- __C__ [changhai.org](https://www.changhai.org): 卢昌海的个人主页，科普作家的自留地，互联网的名胜古迹
- __D__ [douban.com](https://www.douban.com): 人均大文豪
- __E__ [email.——.edu](): 学校邮箱
- __F__ [farseerfc.me](https://farseerfc.me): farseerfc 的博客，本人博客的留言区代码就是根据[他(她？)的教程](https://farseerfc.me/github-issues-as-comments.html)改写成的
- __G__ [github.com](https://github.com): 同性交友网站
- __H__ [hacker-tools.github.io](https://hacker-tools.github.io): 标题党，你以为我是黑客教程，其实我是 Linux 入门哒
- __I__ [idope.se](): 好像已经失效的p2p搜索网站
- __J__ 没有 :-(
- __K__ [kenengba.com](https://kenengba.com): 可能吧，Jason Ng 的博客，号称“互联网的‘新鲜事’”，更新周期以年为单位
- __L__ [localhost:4000/blog/](): 个人博客的本地调试端口
- __M__ [mountaye.github.io/blog/](https://mountaye.github.io/blog/): 个人博客，不要忘记反斜线
- __N__ 没有 :-(
- __O__ [ozdic.com](http://www.ozdic.com/): 一个搜索英语固定搭配的在线词典
- __P__ [program-think.blogspot.com](https://program-think.blogspot.com): 咱也不知道，咱也不敢问
- __Q__ [quantopian.com](https://www.quantopian.com/home): 一个提供量化金融数据接口的平台，数据与主流财经门户的数据有出入
- __R__ [ruanyifeng.com](https://www.ruanyifeng.com/home.html): 阮一峰的个人网站
- __S__ [stackoverflow.com](https://stackoverflow.com): 编程相关的问答网站 ~~（抄代码就完事了）~~
- __T__  ~~（谁能给个邀请码）~~ 没有 :-(
- __U__ 没有 :-(
- __V__ [linux.vbird.org](http://linux.vbird.org/): 鸟哥的 Linux 私房菜
- __W__ [wolfram.com](http://wolfram.com/): ~~世界上第二好的编程语言~~
- __X__ 没有 :-(
- __Y__ [yoitsu.moe](https://blog.yoitsu.moe): 约伊兹的萌狼乡手札
- __Z__ [zh.moegirl.org](https://zh.moegirl.org/Mainpage): 中文萌娘百科，90后中老年人了解00后的窗口


2019 年 2 月 7 日.py | 转载：为什么俺推荐 Python[0]·概述htmlpy

.py | 转载：为什么俺推荐 Python[0]·概述

.pyPython 学习笔记

.html转载和二次创作