标签：nec python 信息 命令 关键字 微软 字母 三元 创建
此模块提供了用于比较序列的类和函数。它可以用于例如比较文件，并且可以产生各种格式的差异信息，包括HTML和上下文以及统一差异。
difflib 模块包含用于计算和处理序列间差异的工具。它特别适用于比较文本，包括使用几种常见差异格式生成报告的函数。
本节中的示例将在扩散数据中使用这个常见的测试difflib_data.py模块:
text1 = """Lorem ipsum dolor sit amet, consectetuer adipiscing
elit. Integer eu lacus accumsan arcu fermentum euismod. Donec
pulvinar porttitor tellus. Aliquam venenatis. Donec facilisis
pharetra tortor. In nec mauris eget magna consequat
convalis. Nam sed sem vitae odio pellentesque interdum. Sed
consequat viverra nisl. Suspendisse arcu metus, blandit quis,
rhoncus ac, pharetra eget, velit. Mauris urna. Morbi nonummy
molestie orci. Praesent nisi elit, fringilla ac, suscipit non,
tristique vel, mauris. Curabitur vel lorem id nisl porta
adipiscing. Suspendisse eu lectus. In nunc. Duis vulputate
tristique enim. Donec quis lectus a justo imperdiet tempus."""
text1_lines = text1.splitlines()
text2 = """Lorem ipsum dolor sit amet, consectetuer adipiscing
elit. Integer eu lacus accumsan arcu fermentum euismod. Donec
pulvinar, porttitor tellus. Aliquam venenatis. Donec facilisis
pharetra tortor. In nec mauris eget magna consequat
convalis. Nam cras vitae mi vitae odio pellentesque interdum. Sed
consequat viverra nisl. Suspendisse arcu metus, blandit quis,
rhoncus ac, pharetra eget, velit. Mauris urna. Morbi nonummy
molestie orci. Praesent nisi elit, fringilla ac, suscipit non,
tristique vel, mauris. Curabitur vel lorem id nisl porta
adipiscing. Duis vulputate tristique enim. Donec quis lectus a
justo imperdiet tempus. Suspendisse eu lectus. In nunc."""
text2_lines = text2.splitlines()
class difflib.Differ：这是一个类，用于比较文本行的序列，并产生人类可读的差异或增量。Differ使用SequenceMatcher来比较行的序列，并比较类似（接近匹配）行内的字符序列。
Differ delta的每一行都以两个字母的代码开头：
class difflib.Differ(linejunk=None, charjunk=None)：
可选的关键字参数linejunk和charjunk用于过滤器功能（或None）：
这些垃圾过滤功能加速匹配以发现差异，并且不会导致任何不同的行或字符被忽略。
通过单个方法使用Differ对象（生成增量）：
每个序列必须包含以换行符结尾的单个单行字符串。这样的序列可以从文件状对象的readlines()方法获得。生成的增量还包括以换行符结束的字符串，可以通过类似于文件的对象的writelines()方法按原样打印。
举例
Differ 的类在文本行序列上工作，并产生人类可读的增量，或者改变指令，包括不同的行内的差异。Differ 的默认输出类似于Unix下的diff命令行工具。它包括来自两个列表的原始输入值，包括通用的值，以及标记数据，以指示进行了哪些更改。
将文本分解为一个单独的行序列，然后将其传递给compare()会产生比在大字符串中传递更容易读的输出。
import difflib
from difflib_data import *
d = difflib.Differ()
diff = d.compare(text1_lines, text2_lines)
print(‘\n‘.join(diff))
示例数据中的两个文本段的开头都是相同的，所以第一行没有任何额外的注释。
Lorem ipsum dolor sit amet, consectetuer adipiscing
elit. Integer eu lacus accumsan arcu fermentum euismod. Donec
数据的第三行已经更改为在修改后的文本中包含一个逗号。这一行的两个版本都被打印出来了，第5行中额外的信息显示了文本被修改的列，其中包括添加了字符的事实。
- pulvinar porttitor tellus. Aliquam venenatis. Donec facilisis
+ pulvinar, porttitor tellus. Aliquam venenatis. Donec facilisis
? +
接下来的几行输出显示额外的空间被删除了。
- pharetra tortor. In nec mauris eget magna consequat
? -
+ pharetra tortor. In nec mauris eget magna consequat
接下来，一个更复杂的变化出现了，用一个短语代替了几个单词。
- convalis. Nam sed sem vitae odio pellentesque interdum. Sed
? - --
+ convalis. Nam cras vitae mi vitae odio pellentesque interdum. Sed
? +++ +++++ +
段落的最后一个句子发生了很大的变化，所以区别是通过移除旧版本和添加新版本来表示的。
consequat viverra nisl. Suspendisse arcu metus, blandit quis,
rhoncus ac, pharetra eget, velit. Mauris urna. Morbi nonummy
molestie orci. Praesent nisi elit, fringilla ac, suscipit non,
tristique vel, mauris. Curabitur vel lorem id nisl porta
- adipiscing. Suspendisse eu lectus. In nunc. Duis vulputate
- tristique enim. Donec quis lectus a justo imperdiet tempus.
+ adipiscing. Duis vulputate tristique enim. Donec quis lectus a
+ justo imperdiet tempus. Suspendisse eu lectus. In nunc.
difflib.unified_diff(a, b, fromfile=‘‘, tofile=‘‘, fromfiledate=‘‘, tofiledate=‘‘, n=3, lineterm=‘\n‘)：比较a和b（字符串列表）；以统一差分格式返回增量（generator生成增量线）。
统一差异是一种紧凑的方式，仅显示已更改的行，以及几行上下文。更改以内联样式显示（而不是单独的前/后块）。上下文线的数量由n设置，默认为三个。
默认情况下，使用尾随换行创建diff控制行（具有---，+++或@@的那些）这有助于使从io.IOBase.readlines()创建的输入产生适合与io.IOBase.writelines()一起使用的差异，因为输入和输出具有尾随换行符。
对于没有尾随换行符的输入，将lineterm参数设置为""，以便输出将一律换行。
上下文差异格式通常具有文件名和修改时间的头。可以使用fromfile，tofile，fromfiledate和tofiledate的字符串指定这些中的任何一个或全部。修改时间通常以ISO 8601格式表示。如果未指定，则字符串默认为空。
举例
尽管Differ 的类显示了所有的输入行，但是一个统一的diff只包含了修改的行和一些上下文。unified_diff()函数产生这种类型的输出。
import difflib
from difflib_data import *
diff = difflib.unified_diff(
text1_lines,
text2_lines,
lineterm=‘‘,
)
print(‘\n‘.join(list(diff)))
lineterm参数用于告诉unified_diff()跳过新行到它返回的控制行，因为输入行不包括它们。当打印出来的时候，所有的行都添加了换行符。对于许多流行的版本控制工具的用户来说，输出应该是很熟悉的。
---
+++
@@ -1,11 +1,11 @@
Lorem ipsum dolor sit amet, consectetuer adipiscing
elit. Integer eu lacus accumsan arcu fermentum euismod. Donec
-pulvinar porttitor tellus. Aliquam venenatis. Donec facilisis
-pharetra tortor. In nec mauris eget magna consequat
-convalis. Nam sed sem vitae odio pellentesque interdum. Sed
+pulvinar, porttitor tellus. Aliquam venenatis. Donec facilisis
+pharetra tortor. In nec mauris eget magna consequat
+convalis. Nam cras vitae mi vitae odio pellentesque interdum. Sed
consequat viverra nisl. Suspendisse arcu metus, blandit quis,
rhoncus ac, pharetra eget, velit. Mauris urna. Morbi nonummy
molestie orci. Praesent nisi elit, fringilla ac, suscipit non,
tristique vel, mauris. Curabitur vel lorem id nisl porta
-adipiscing. Suspendisse eu lectus. In nunc. Duis vulputate
-tristique enim. Donec quis lectus a justo imperdiet tempus.
+adipiscing. Duis vulputate tristique enim. Donec quis lectus a
+justo imperdiet tempus. Suspendisse eu lectus. In nunc.
class difflib.SequenceMatcher(isjunk=None, a=‘‘, b=‘‘, autojunk=True)：可选参数isjunk必须是None（默认值）或单参数函数，它接受一个序列元素，并且当且仅当元素是“junk”被忽略。将None传递给isjunk等效于传递lambda x： 0 ；换句话说，没有元素被忽略。例如，pass。
如果你将行作为字符序列进行比较，并且不想在空白或硬标签上同步。
可选参数a和b是要比较的序列；两者默认为空字符串。这两个序列的元素必须hashable。
可选参数autojunk可用于禁用自动垃圾启发式。
SequenceMatcher对象具有以下方法：
http://usyiyi.cn/translate/python_352/library/difflib.html
举例
所有产生差异序列的函数都接受参数，以指示应该忽略哪些行，以及应该忽略行中的哪些字符。例如，这些参数可用于跳过文件的两个版本中的标记或空格更改。
from difflib import SequenceMatcher
def show_results(match):
print(‘ a = {}‘.format(match.a))
print(‘ b = {}‘.format(match.b))
print(‘ size = {}‘.format(match.size))
i, j, k = match
print(‘ A[a:a+size] = {!r}‘.format(A[i:i + k]))
print(‘ B[b:b+size] = {!r}‘.format(B[j:j + k]))
A = " abcd"
B = "abcd abcd"
print(‘A = {!r}‘.format(A))
print(‘B = {!r}‘.format(B))
print(‘\nWithout junk detection:‘)
s1 = SequenceMatcher(None, A, B)
match1 = s1.find_longest_match(0, len(A), 0, len(B))
show_results(match1)
print(‘\nTreat spaces as junk:‘)
s2 = SequenceMatcher(lambda x: x == " ", A, B)
match2 = s2.find_longest_match(0, len(A), 0, len(B))
show_results(match2)
Differ的默认值不是明确忽略任何行或字符，而是依赖SequenceMatcher检测噪声的能力。ndiff() 的默认值是忽略空格和制表符。
A = ‘ abcd‘
B = ‘abcd abcd‘
Without junk detection:
a = 0
b = 4
size = 5
A[a:a+size] = ‘ abcd‘
B[b:b+size] = ‘ abcd‘
Treat spaces as junk:
a = 1
b = 0
size = 4
A[a:a+size] = ‘abcd‘
B[b:b+size] = ‘abcd‘
举例
SequenceMatcher类可以比较任何类型的两个序列，只要该值是可哈希的。 它使用一种算法来识别序列中最长的连续匹配块，消除对实际数据无贡献的“junk”值。
函数get_opcodes()返回修改第一个序列以使其与第二个序列匹配的指令列表。 指令被编码为五元组元组，包括字符串指令（“opcode”，见下表）以及序列中的两对起始和停止索引（表示为i1，i2，j1和j2）。
| Opcode | Definition |
|---|---|
| ‘replace‘ | Replace a[i1:i2] with b[j1:j2] |
| ‘delete‘ | Remove a[i1:i2] entirely |
| ‘insert‘ | Insert b[j1:j2] at a[i1:i1] |
| ‘equal‘ | The subsequences are already equal |
import difflib
s1 = [1, 2, 3, 5, 6, 4]
s2 = [2, 3, 5, 4, 6, 1]
print(‘Initial data:‘)
print(‘s1 =‘, s1)
print(‘s2 =‘, s2)
print(‘s1 == s2:‘, s1 == s2)
print()
matcher = difflib.SequenceMatcher(None, s1, s2)
for tag, i1, i2, j1, j2 in reversed(matcher.get_opcodes()):
if tag == ‘delete‘:
print(‘Remove {} from positions [ {}: {}]‘.format(s1[i1:i2], i1, i2))
print(‘ before =‘, s1)
del s1[i1:i2]
elif tag == ‘equal‘:
print(‘s1[{}:{}] and s2[{}:{}] are the same‘.format(i1, i2, j1, j2))
elif tag == ‘insert‘:
print(‘Insert {} from s2[{}:{}] into s1 at {}‘.format(s2[j1:j2], j1, j2, i1))
print(‘ before =‘, s1)
s1[i1:i2] = s2[j1:j2]
elif tag == ‘replace‘:
print((‘Replace {} from s1[{}:{}]‘‘with {} from s2[{}:{}]‘).format(s1[i1:i2], i1, i2, s2[j1:j2], j1, j2))
print(‘ before =‘, s1)
s1[i1:i2] = s2[j1:j2]
print(‘ after =‘, s1, ‘\n‘)
print(‘s1 == s2:‘, s1 == s2)
本例比较两个整数列表，并使用getopcode()来获得将原始列表转换为新版本的指令。这些修改被应用于相反的顺序，这样在添加和删除条目之后，列表索引仍然是正确的。
Initial data:
s1 = [1, 2, 3, 5, 6, 4]
s2 = [2, 3, 5, 4, 6, 1]
s1 == s2: False
Replace [4] from s1[5:6]with [1] from s2[5:6]
before = [1, 2, 3, 5, 6, 4]
after = [1, 2, 3, 5, 6, 1]
s1[4:5] and s2[4:5] are the same
after = [1, 2, 3, 5, 6, 1]
Insert [4] from s2[3:4] into s1 at 4
before = [1, 2, 3, 5, 6, 1]
after = [1, 2, 3, 5, 4, 6, 1]
s1[1:4] and s2[0:3] are the same
after = [1, 2, 3, 5, 4, 6, 1]
Remove [1] from positions [ 0: 1]
before = [1, 2, 3, 5, 4, 6, 1]
after = [2, 3, 5, 4, 6, 1]
s1 == s2: True
标签：nec python 信息 命令 关键字 微软 字母 三元 创建
原文地址：http://www.cnblogs.com/cuchadanfan/p/7251813.html
