图像处理中，对图像矩阵经历一系列的处理之后，常常会有一些像素值出现小于 0 或大于 255 的情况，显然是不符合 8 位深的要求的，此时我们就需做如下截断处理：I[I > 255] = 255;I[I < 0] = 0;当然我们也可以使用 where 语句：I = np.where(np.where(I > 255, 255, I) < 0, 0, I);

他山之石系列，阅读别人家的代码，学习逻辑的设计，变量的命名。这是 TED 一期，对大神 Linus 的访谈；Node *head, *prev, *walk;void remove_list_entry(Node* entry){ prev = NULL; // walk 这一变量名，十分巧妙， // 变量命名的不二法门就是对应其物理（实际）意义 walk = h

内积，对应位相乘再相加；用到了 map，用到了 reduce，用到了 zip，用到了 函数对象；import operatordef inner_product(x, y) reduce reduce(operator.add, map(lambda x: x[0]+x[1], zip(x, y)))

G(x)=sign⎛⎝⎜⎜∑t=1Tαtsign(wTtx)g(x)⎞⎠⎟⎟G(\mathbf x)=\text{sign}\left (\sum_{t=1}^T\alpha_t\underbrace{\text{sign}(\mathbf w_t^T\mathbf x)}_{g(\mathbf x)}\right )AND 与问题G(x)=−1+g1(x)+g2(x)G(

如果一个集合的大小为 mm，从集合中取 nn 次，可能的情况为 mnm^n 。>> s = [-1, 1]>> [(x, y) for x in s for y in s][(-1, -1), (-1, 1), (1, -1), (1, 1)]

重复利用已有的宏定义。#define MIN(a, b) ((a) < (b) ? (a) : (b))#define MIN3(a, b, c) MIN(MIN((a), (b)), (c))#define MIN4(a, b, c, d) MIN(MIN3((a), (b), (c)), (d))

假设两点为 M0M_0, M1M_1，则两点的中点为 C=M0+M12C=\frac{M_0+M_1}2，设 M0M_0, M1M_1 连线外一点 XX，此时如何判断点 XX，离 M0M_0, M1M_1 哪个点更近（不允许使用欧式距离直接计算）。我们取中点 CC 与 XX 的连线（CX→\vec {CX}），显然其与 M0M1M_0M_1连线（M0M1→\vec {M_0M_1}）的夹角（是否大于

返回所有符合条件的下标，自然想到的是用列表解析（list comprehension），并在列表解析中增加一个断言（if pred，是否符合条件），那么又该如何返回其下标呢，是使用 index() 成员函数吗？比如，我们要获取列表中所有元素为 0 的下标：>>> l = [0, 2, 0]>>> [l.index(l) for i in l if l == 0]输出的结果为：[0, 0]因为 in

<string> 文件中的 string 类是不具有 split（切分出字符串构成的数组）这一十分实用的成员函数的。使用其提供的 find 和 substr 两个核心成员函数，也可轻易实现 split 的功能。vector<string> split(string& str, char splited){ vector<string> vec; int pos = str.fin

如果数组或者字符串的长度为 n，则全部子串（子数组）的规模为： n+(n−1)+⋯+1=n(n+1)2n+(n-1)+\cdots+1=\frac{n(n+1)}2for (size_t i = 0; i < n; ++i){ for (size_t j = i+1; j < n; ++j) ...}外层循环表示以其为开始的子数组（或子串），内层表示截止；

可能问题没有表述清楚，我们通常见到的都是访问相邻位，像这样：for (int i = 0; i < n-1; ++i){ seq[i], seq[i+1];}也即这样，[0, 1], [1, 2], [2, 3],… [n-2, n-1], 就像循环标识的一样，共有 n-1 pairs。现在我们问，如何实现对相邻的奇数位偶数位的访问，如 [0, 1], [2, 3], [n-2, n-1

高维向量的邻域一般作为一些优化方法执行下一步时的重要依据，比如爬山算法，其相较随机游走的跳跃式搜索，最大的改进正在于它的下一步不是跳跃式的，而是在自己的邻域内行走。这种做法的一个直观解释正在于，最优解重在次优解的邻域内取得。x = [1, 1, 1]neighbors = []for i in range(len(x)): neighbors.append(x[:i]+[x[i]+1]+

考虑一个 3-5-1 的神经网络拓扑结构，让你给出整个网络结构可能达到的权值的数目，或者层间权值矩阵的 shape，手工计算即是：(3+1)*5+(5+1)*1=26, 0-1: W_{5*4}, 1-2: W_{1*6}。此时我们需遍历的就不再单单是单点的 list 元素，一种解决方案：topo = [3, 5, 1]num_weights = sum([topo[i+1]*(1+topo[i]

（1）数组也能实现一种映射（map），将下标映射为下标对应的值，数组和字典甚至映射的形式都是一样的，都是使用中括号。arr[0] = 1;m["InsideZhang"] = 23;（2）数组能做的事，字典都能完成；而字典能做的事，数组却未必能。也即数组是 key 受限（必须为无符号整型）的字典。或者说字典是下标增强的数组。（3）下标之于数组，如同 key 之于字典，不过数组的下标只可以是无符

使用循环；阶乘的实现：def fac(n): r = 1. for i in range(1, n+1): r *= i return r排列：Anm=m!n!=(m−n+1)⋯mA_m^n=\frac{m!}{n!}=(m-n+1)\cdots mdef perm(m, n): r = 1. for i in range(n):

不小于一个数的最小2的幂次方，对于 10 就是 16，对于 21 就是 32.以下实现摘自 java HashMap 的源码：static final int tableSizeFor(int cap) { int n = cap - 1; n |= n &gt;&gt;&gt; 1; n |= n &gt;&gt;&gt; 2; n |= n &gt;&g...

Theano编程的核心是用符号占位把数学关系表示出来。import theano.tensor as Tx = T.dmatrix('x')y = x*2.>>> y.owner.op.name'Elemwise{mul,no_inplace}'>>> y.owner.inputs[x, DimShuffle{x,x}.0]>>> y.owner.inputs[0]x>>> y.own

人为地定义一些“无意义”的宏（宏名本身有意义），以起到提升代码程序的可读性。1. IN/OUT指定参数用于输入还是输出：#define IN#define OUTvoid InvertMatrix( IN Matrix originalMatrix, OUT Matrix *resultMatrix);// IN OUT 连用，表示直接在输入对象上进行修...

>> from datetime import datetime>> now = datetime.now()>> now.strftime('%Y-%m-%d')'2018-01-29'如果此时我们想转换为 2018-1-29的形式，有如下的两种方式：法 1：分别转换为 int 型以消除前导 0：year = str(int(now.strftime('%Y')))mont

1. Python 的方式a, b = b, a2. 异或（避免中间变量的定义）(a⊕b)⊕a=b(a⊕b)⊕b=a" role="presentation">(a⊕b)⊕a=b(a⊕b)⊕b=a(a⊕b)⊕a=b(a⊕b)⊕b=a(a\oplus b)\oplus a=b\\(a\oplus b)\oplus b =a

区分文件和目录：ls -Fls -F -R：递归显示目录仅改变文件的修改时间，而不修改文件的内容：touch filename；使用 file 命令查看文件类型：ASCII textdirectoryshell script0. 常用 tricks仅显示目录ls -l | grep “^d”：以 d 开头ls -F | grep “/$”：以 / 结尾...

对 zip 进行迭代，取出的元素是二元 tuple，二元元组由各自序列的对应位的元素构成。# zip(l1, l2)[(x, l2[i]) for i, x in enumerate(l1)]

使用 min 函数指定访问的最终位置，本质上是增加一个条件判断

1. list of tuples 仿真dict这里的 tuple 一般为二元，仿真键值对[('name', 'zch'), ('age', 18)]2. list of lists 仿真矩阵3. dict of dict 仿真图这里表达的 dict of dict 可能不甚准确，嵌套字典也许会更恰当一些，说的是，外层字典的每一个 key 对应的 value 仍然是一个字典。此时访问具体元素时，仍然

为 if 的条件判断表达式，传一个永假的语句，来注释一段代码：# Pythonif False: ... ... ...# C/C++if (false) { ... ...}永远不要直接删去以前的代码，雁过留声，码过要有痕，以方便进行版本管理。当然这样做还有一点好处在于，方便进行代码段前后的对比。

假定 X 是一个 0-1 元素构成的布尔矩阵，则对其取反，0 变成 1，1 变为 0（True 变为 False，False 变成 True），只需要一步简单的操作：Y = (X == False)

x=max(x,−2)x=min(x,3)}⇒x=min(max(x,−2),3)\left .\begin{split}&x = \max(x,-2)\\&x=\min(x,3)\end{split}\right \}\Rightarrow x=\min(\max(x,-2),3)（1）第一个赋值表达式表示：x≥−2x\geq -2，-2 为下界（2）第二个赋值表达式表示：x≤3x\l

Trick（一）——判断一个数的位数计算一个数的十进制的位数，我们用以10为底该数的对数，再取整加1； 10m<x<10m+1m<log10x<m+1m=⌊log10x⌋+110^m<x<10^{m+1}\\m<\log_{10}x<m+1\\m=\lfloor\log_{10}x\rfloor+1 同理计算一个数对应的二进制的位数，我么用以 2 为底的该数的对数，再取整加1； 2m<

首先来看使用 np.argsort 得到下标：>>> x = [1, 3, 2]>>> np.argsort(x)array([0, 2, 1], dtype=int32)如何不使用 np.argsort 的情况依然获得排序后元素所在的下标呢？通过 enumerate，为序列中的每一个元素增加一个维度，也即绑定下标：>>> [x[0] for x in sorted(enumerate(x),

求解的关键在引用计数，可以使用字典，也可以使用 collections 模块中的 Counter。统计 label（序列）各个标签值出现的次数统计 label（序列）各个标签值出现的次数，来计算 label 的概率分布，或者样本集的香农熵。法一：使用字典labelCnt = {}for featVec in dataset: label = featVec[-1] if labe

Trick（七）——list of lists 行和、列和的计算在具体的应用中，list of lists 这一存储模型，可看做是对矩阵的模拟，在实际应用中扮演着不同的角色，对于一个图结构而言，它可以表示图节点的邻接矩阵，行和意味着顶点的出度，列和意味着入度（入度为 0 的点，在进行拓扑排序时扮演着重要作用，它是拓扑排序的起点）。

Built-in Functions-alldef any(iterable): for element in iterable: if element: return True return Falsedef all(iterable): for element in iterable: if not element:

翻转字符串，也即：abcd ⇒ dcbavoid ReverseString(char* s, int from, int to){ while(from < to) { char t = s[from]; s[from++] = s[to]; a[to--] = t; }}

循环左移（ROL，Ring Shift Left）可用于字符串的旋转当中。abcdef ⇒ defabc可看做整个字符串循环左移三位；// 循环左移1位，作为左移 k 位的辅助函数// n 标识字符串的长度void ROL1(char* s, int n){ char t = s[0]; for (int i = 1; i < n; ++i) s[i-1] =

stack：实现了先入后出（FILO）的进出顺序，“后来居上”。如果仅使用 list 的 ：append(x)（插入到尾部） pop()（从尾部弹出）（不含参数，默认执行的是pop(-1)，也即删除最后一个）两个成员函数，即可实现一种先入后出的机制。l, n = [], 5for i in range(n): l.append(i)for _ in range(n): l.

from random import randrangen = 100G = [[randrange(2) for _ in range(n)] for _ in range(n)] # randrange(2)：产生 0/1

等概率自然就是每个数被选中的概率为： p=mNp=\frac mN 通过 if 条件判断，以及 rand() 随机数产生器，我们可轻易产生这样的概率判断：float p = m/float(N);if (rand()/float(RAND_MAX) < p){ ...}在 N≫mN \gg m 的情况下，我们可实现一种简易版的随机数生成器：int m, N = 10, 1000

没想到更高明的做法，这里先给出一个朴素版的，自然也是二层循环，不过外层是遍历列，内层遍历行：def transpose(data): newdata = [] for j in range(len(data[0])): row = [data[i][j] for i in range(len(data))] newdata.append(row)

m, n = len(A), len(A[0])ranges = [(min(A[i][j] for i in range(m)), max(A[i][j] for i in range(m))) for j in range(n)] 注：位于 list comprehension 中的 for 循环，如果是并列关系，如：[ for i in range(m) for j in range(n)]

所谓网页的 title 信息，就是在一个浏览器打开一个网页，在浏览器的顶部显示的标题信息。那么又该如何获取这一 title 信息，进行拷贝，而不是手动输入呢？ctrl + shift + i：进入开发者工具，找到页面的 title 标签，即可获取此网页的 title 信息：