1243 lines
128 KiB
HTML
1243 lines
128 KiB
HTML
<!DOCTYPE html>
|
||
|
||
<html lang="en" data-content_root="../">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
|
||
<meta property="og:title" content="difflib — Helpers for computing deltas" />
|
||
<meta property="og:type" content="website" />
|
||
<meta property="og:url" content="https://docs.python.org/3/library/difflib.html" />
|
||
<meta property="og:site_name" content="Python documentation" />
|
||
<meta property="og:description" content="Source code: Lib/difflib.py This module provides classes and functions for comparing sequences. It can be used for example, for comparing files, and can produce information about file differences i..." />
|
||
<meta property="og:image" content="https://docs.python.org/3/_static/og-image.png" />
|
||
<meta property="og:image:alt" content="Python documentation" />
|
||
<meta name="description" content="Source code: Lib/difflib.py This module provides classes and functions for comparing sequences. It can be used for example, for comparing files, and can produce information about file differences i..." />
|
||
<meta property="og:image:width" content="200">
|
||
<meta property="og:image:height" content="200">
|
||
<meta name="theme-color" content="#3776ab">
|
||
|
||
<title>difflib — Helpers for computing deltas — Python 3.13.3 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
|
||
<link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" />
|
||
<link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=23252803" />
|
||
<link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=5349f25f" />
|
||
|
||
<script src="../_static/documentation_options.js?v=5d57ca2d"></script>
|
||
<script src="../_static/doctools.js?v=9bcbadda"></script>
|
||
<script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
|
||
|
||
<script src="../_static/sidebar.js"></script>
|
||
|
||
<link rel="search" type="application/opensearchdescription+xml"
|
||
title="Search within Python 3.13.3 documentation"
|
||
href="../_static/opensearch.xml"/>
|
||
<link rel="author" title="About these documents" href="../about.html" />
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="copyright" title="Copyright" href="../copyright.html" />
|
||
<link rel="next" title="textwrap — Text wrapping and filling" href="textwrap.html" />
|
||
<link rel="prev" title="re — Regular expression operations" href="re.html" />
|
||
|
||
<link rel="canonical" href="https://docs.python.org/3/library/difflib.html">
|
||
|
||
|
||
|
||
|
||
|
||
<style>
|
||
@media only screen {
|
||
table.full-width-table {
|
||
width: 100%;
|
||
}
|
||
}
|
||
</style>
|
||
<link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">
|
||
<link rel="shortcut icon" type="image/png" href="../_static/py.svg" />
|
||
<script type="text/javascript" src="../_static/copybutton.js"></script>
|
||
<script type="text/javascript" src="../_static/menu.js"></script>
|
||
<script type="text/javascript" src="../_static/search-focus.js"></script>
|
||
<script type="text/javascript" src="../_static/themetoggle.js"></script>
|
||
<script type="text/javascript" src="../_static/rtd_switcher.js"></script>
|
||
<meta name="readthedocs-addons-api-version" content="1">
|
||
|
||
</head>
|
||
<body>
|
||
<div class="mobile-nav">
|
||
<input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"
|
||
aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />
|
||
<nav class="nav-content" role="navigation">
|
||
<label for="menuToggler" class="toggler__label">
|
||
<span></span>
|
||
</label>
|
||
<span class="nav-items-wrapper">
|
||
<a href="https://www.python.org/" class="nav-logo">
|
||
<img src="../_static/py.svg" alt="Python logo"/>
|
||
</a>
|
||
<span class="version_switcher_placeholder"></span>
|
||
<form role="search" class="search" action="../search.html" method="get">
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">
|
||
<path fill-rule="nonzero" fill="currentColor" d="M15.5 14h-.79l-.28-.27a6.5 6.5 0 001.48-5.34c-.47-2.78-2.79-5-5.59-5.34a6.505 6.505 0 00-7.27 7.27c.34 2.8 2.56 5.12 5.34 5.59a6.5 6.5 0 005.34-1.48l.27.28v.79l4.25 4.25c.41.41 1.08.41 1.49 0 .41-.41.41-1.08 0-1.49L15.5 14zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path>
|
||
</svg>
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" />
|
||
<input type="submit" value="Go"/>
|
||
</form>
|
||
</span>
|
||
</nav>
|
||
<div class="menu-wrapper">
|
||
<nav class="menu" role="navigation" aria-label="main navigation">
|
||
<div class="language_switcher_placeholder"></div>
|
||
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label>
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">difflib</span></code> — Helpers for computing deltas</a><ul>
|
||
<li><a class="reference internal" href="#sequencematcher-objects">SequenceMatcher Objects</a></li>
|
||
<li><a class="reference internal" href="#sequencematcher-examples">SequenceMatcher Examples</a></li>
|
||
<li><a class="reference internal" href="#differ-objects">Differ Objects</a></li>
|
||
<li><a class="reference internal" href="#differ-example">Differ Example</a></li>
|
||
<li><a class="reference internal" href="#a-command-line-interface-to-difflib">A command-line interface to difflib</a></li>
|
||
<li><a class="reference internal" href="#ndiff-example">ndiff example</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="re.html"
|
||
title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">re</span></code> — Regular expression operations</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="textwrap.html"
|
||
title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">textwrap</span></code> — Text wrapping and filling</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/library/difflib.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</nav>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
accesskey="I">index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="textwrap.html" title="textwrap — Text wrapping and filling"
|
||
accesskey="N">next</a> |</li>
|
||
<li class="right" >
|
||
<a href="re.html" title="re — Regular expression operations"
|
||
accesskey="P">previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="text.html" accesskey="U">Text Processing Services</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">difflib</span></code> — Helpers for computing deltas</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<section id="module-difflib">
|
||
<span id="difflib-helpers-for-computing-deltas"></span><h1><code class="xref py py-mod docutils literal notranslate"><span class="pre">difflib</span></code> — Helpers for computing deltas<a class="headerlink" href="#module-difflib" title="Link to this heading">¶</a></h1>
|
||
<p><strong>Source code:</strong> <a class="extlink-source reference external" href="https://github.com/python/cpython/tree/3.13/Lib/difflib.py">Lib/difflib.py</a></p>
|
||
<hr class="docutils" />
|
||
<p>This module provides classes and functions for comparing sequences. It
|
||
can be used for example, for comparing files, and can produce information
|
||
about file differences in various formats, including HTML and context and unified
|
||
diffs. For comparing directories and files, see also, the <a class="reference internal" href="filecmp.html#module-filecmp" title="filecmp: Compare files efficiently."><code class="xref py py-mod docutils literal notranslate"><span class="pre">filecmp</span></code></a> module.</p>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">SequenceMatcher</span></span></dt>
|
||
<dd><p>This is a flexible class for comparing pairs of sequences of any type, so long
|
||
as the sequence elements are <a class="reference internal" href="../glossary.html#term-hashable"><span class="xref std std-term">hashable</span></a>. The basic algorithm predates, and is a
|
||
little fancier than, an algorithm published in the late 1980’s by Ratcliff and
|
||
Obershelp under the hyperbolic name “gestalt pattern matching.” The idea is to
|
||
find the longest contiguous matching subsequence that contains no “junk”
|
||
elements; these “junk” elements are ones that are uninteresting in some
|
||
sense, such as blank lines or whitespace. (Handling junk is an
|
||
extension to the Ratcliff and Obershelp algorithm.) The same
|
||
idea is then applied recursively to the pieces of the sequences to the left and
|
||
to the right of the matching subsequence. This does not yield minimal edit
|
||
sequences, but does tend to yield matches that “look right” to people.</p>
|
||
<p><strong>Timing:</strong> The basic Ratcliff-Obershelp algorithm is cubic time in the worst
|
||
case and quadratic time in the expected case. <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> is
|
||
quadratic time for the worst case and has expected-case behavior dependent in a
|
||
complicated way on how many elements the sequences have in common; best case
|
||
time is linear.</p>
|
||
<p><strong>Automatic junk heuristic:</strong> <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> supports a heuristic that
|
||
automatically treats certain sequence items as junk. The heuristic counts how many
|
||
times each individual item appears in the sequence. If an item’s duplicates (after
|
||
the first one) account for more than 1% of the sequence and the sequence is at least
|
||
200 items long, this item is marked as “popular” and is treated as junk for
|
||
the purpose of sequence matching. This heuristic can be turned off by setting
|
||
the <code class="docutils literal notranslate"><span class="pre">autojunk</span></code> argument to <code class="docutils literal notranslate"><span class="pre">False</span></code> when creating the <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a>.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Added the <em>autojunk</em> parameter.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="difflib.Differ">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">Differ</span></span><a class="headerlink" href="#difflib.Differ" title="Link to this definition">¶</a></dt>
|
||
<dd><p>This is a class for comparing sequences of lines of text, and producing
|
||
human-readable differences or deltas. Differ uses <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a>
|
||
both to compare sequences of lines, and to compare sequences of characters
|
||
within similar (near-matching) lines.</p>
|
||
<p>Each line of a <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a> delta begins with a two-letter code:</p>
|
||
<table class="docutils align-default">
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>Code</p></th>
|
||
<th class="head"><p>Meaning</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">'-</span> <span class="pre">'</span></code></p></td>
|
||
<td><p>line unique to sequence 1</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">'+</span> <span class="pre">'</span></code></p></td>
|
||
<td><p>line unique to sequence 2</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">'</span>  <span class="pre">'</span></code></p></td>
|
||
<td><p>line common to both sequences</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">'?</span> <span class="pre">'</span></code></p></td>
|
||
<td><p>line not present in either input sequence</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<p>Lines beginning with ‘<code class="docutils literal notranslate"><span class="pre">?</span></code>’ attempt to guide the eye to intraline differences,
|
||
and were not present in either input sequence. These lines can be confusing if
|
||
the sequences contain whitespace characters, such as spaces, tabs or line breaks.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="difflib.HtmlDiff">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">HtmlDiff</span></span><a class="headerlink" href="#difflib.HtmlDiff" title="Link to this definition">¶</a></dt>
|
||
<dd><p>This class can be used to create an HTML table (or a complete HTML file
|
||
containing the table) showing a side by side, line by line comparison of text
|
||
with inter-line and intra-line change highlights. The table can be generated in
|
||
either full or contextual difference mode.</p>
|
||
<p>The constructor for this class is:</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.HtmlDiff.__init__">
|
||
<span class="sig-name descname"><span class="pre">__init__</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">tabsize</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">8</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">wrapcolumn</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">linejunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">charjunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">IS_CHARACTER_JUNK</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.HtmlDiff.__init__" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Initializes instance of <a class="reference internal" href="#difflib.HtmlDiff" title="difflib.HtmlDiff"><code class="xref py py-class docutils literal notranslate"><span class="pre">HtmlDiff</span></code></a>.</p>
|
||
<p><em>tabsize</em> is an optional keyword argument to specify tab stop spacing and
|
||
defaults to <code class="docutils literal notranslate"><span class="pre">8</span></code>.</p>
|
||
<p><em>wrapcolumn</em> is an optional keyword to specify column number where lines are
|
||
broken and wrapped, defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code> where lines are not wrapped.</p>
|
||
<p><em>linejunk</em> and <em>charjunk</em> are optional keyword arguments passed into <a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">ndiff()</span></code></a>
|
||
(used by <a class="reference internal" href="#difflib.HtmlDiff" title="difflib.HtmlDiff"><code class="xref py py-class docutils literal notranslate"><span class="pre">HtmlDiff</span></code></a> to generate the side by side HTML differences). See
|
||
<a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">ndiff()</span></code></a> documentation for argument default values and descriptions.</p>
|
||
</dd></dl>
|
||
|
||
<p>The following methods are public:</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.HtmlDiff.make_file">
|
||
<span class="sig-name descname"><span class="pre">make_file</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">fromlines</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tolines</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromdesc</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">todesc</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">context</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">numlines</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">5</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">charset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'utf-8'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.HtmlDiff.make_file" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compares <em>fromlines</em> and <em>tolines</em> (lists of strings) and returns a string which
|
||
is a complete HTML file containing a table showing line by line differences with
|
||
inter-line and intra-line changes highlighted.</p>
|
||
<p><em>fromdesc</em> and <em>todesc</em> are optional keyword arguments to specify from/to file
|
||
column header strings (both default to an empty string).</p>
|
||
<p><em>context</em> and <em>numlines</em> are both optional keyword arguments. Set <em>context</em> to
|
||
<code class="docutils literal notranslate"><span class="pre">True</span></code> when contextual differences are to be shown, else the default is
|
||
<code class="docutils literal notranslate"><span class="pre">False</span></code> to show the full files. <em>numlines</em> defaults to <code class="docutils literal notranslate"><span class="pre">5</span></code>. When <em>context</em>
|
||
is <code class="docutils literal notranslate"><span class="pre">True</span></code> <em>numlines</em> controls the number of context lines which surround the
|
||
difference highlights. When <em>context</em> is <code class="docutils literal notranslate"><span class="pre">False</span></code> <em>numlines</em> controls the
|
||
number of lines which are shown before a difference highlight when using the
|
||
“next” hyperlinks (setting to zero would cause the “next” hyperlinks to place
|
||
the next difference highlight at the top of the browser without any leading
|
||
context).</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p><em>fromdesc</em> and <em>todesc</em> are interpreted as unescaped HTML and should be
|
||
properly escaped while receiving input from untrusted sources.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.5: </span><em>charset</em> keyword-only argument was added. The default charset of
|
||
HTML document changed from <code class="docutils literal notranslate"><span class="pre">'ISO-8859-1'</span></code> to <code class="docutils literal notranslate"><span class="pre">'utf-8'</span></code>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.HtmlDiff.make_table">
|
||
<span class="sig-name descname"><span class="pre">make_table</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">fromlines</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tolines</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromdesc</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">todesc</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">context</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">numlines</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">5</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.HtmlDiff.make_table" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compares <em>fromlines</em> and <em>tolines</em> (lists of strings) and returns a string which
|
||
is a complete HTML table showing line by line differences with inter-line and
|
||
intra-line changes highlighted.</p>
|
||
<p>The arguments for this method are the same as those for the <a class="reference internal" href="#difflib.HtmlDiff.make_file" title="difflib.HtmlDiff.make_file"><code class="xref py py-meth docutils literal notranslate"><span class="pre">make_file()</span></code></a>
|
||
method.</p>
|
||
</dd></dl>
|
||
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.context_diff">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">context_diff</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">3</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">lineterm</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'\n'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.context_diff" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compare <em>a</em> and <em>b</em> (lists of strings); return a delta (a <a class="reference internal" href="../glossary.html#term-generator"><span class="xref std std-term">generator</span></a>
|
||
generating the delta lines) in context diff format.</p>
|
||
<p>Context diffs are a compact way of showing just the lines that have changed plus
|
||
a few lines of context. The changes are shown in a before/after style. The
|
||
number of context lines is set by <em>n</em> which defaults to three.</p>
|
||
<p>By default, the diff control lines (those with <code class="docutils literal notranslate"><span class="pre">***</span></code> or <code class="docutils literal notranslate"><span class="pre">---</span></code>) are created
|
||
with a trailing newline. This is helpful so that inputs created from
|
||
<a class="reference internal" href="io.html#io.IOBase.readlines" title="io.IOBase.readlines"><code class="xref py py-func docutils literal notranslate"><span class="pre">io.IOBase.readlines()</span></code></a> result in diffs that are suitable for use with
|
||
<a class="reference internal" href="io.html#io.IOBase.writelines" title="io.IOBase.writelines"><code class="xref py py-func docutils literal notranslate"><span class="pre">io.IOBase.writelines()</span></code></a> since both the inputs and outputs have trailing
|
||
newlines.</p>
|
||
<p>For inputs that do not have trailing newlines, set the <em>lineterm</em> argument to
|
||
<code class="docutils literal notranslate"><span class="pre">""</span></code> so that the output will be uniformly newline free.</p>
|
||
<p>The context diff format normally has a header for filenames and modification
|
||
times. Any or all of these may be specified using strings for <em>fromfile</em>,
|
||
<em>tofile</em>, <em>fromfiledate</em>, and <em>tofiledate</em>. The modification times are normally
|
||
expressed in the ISO 8601 format. If not specified, the
|
||
strings default to blanks.</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span><span class="w"> </span><span class="nn">sys</span>
|
||
<span class="gp">>>> </span><span class="kn">from</span><span class="w"> </span><span class="nn">difflib</span><span class="w"> </span><span class="kn">import</span> <span class="o">*</span>
|
||
<span class="gp">>>> </span><span class="n">s1</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'bacon</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'eggs</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'ham</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'guido</span><span class="se">\n</span><span class="s1">'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">s2</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'python</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'eggy</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'hamster</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'guido</span><span class="se">\n</span><span class="s1">'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">writelines</span><span class="p">(</span><span class="n">context_diff</span><span class="p">(</span><span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">,</span> <span class="n">fromfile</span><span class="o">=</span><span class="s1">'before.py'</span><span class="p">,</span>
|
||
<span class="gp">... </span> <span class="n">tofile</span><span class="o">=</span><span class="s1">'after.py'</span><span class="p">))</span>
|
||
<span class="go">*** before.py</span>
|
||
<span class="go">--- after.py</span>
|
||
<span class="go">***************</span>
|
||
<span class="go">*** 1,4 ****</span>
|
||
<span class="go">! bacon</span>
|
||
<span class="go">! eggs</span>
|
||
<span class="go">! ham</span>
|
||
<span class="go"> guido</span>
|
||
<span class="go">--- 1,4 ----</span>
|
||
<span class="go">! python</span>
|
||
<span class="go">! eggy</span>
|
||
<span class="go">! hamster</span>
|
||
<span class="go"> guido</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>See <a class="reference internal" href="#difflib-interface"><span class="std std-ref">A command-line interface to difflib</span></a> for a more detailed example.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.get_close_matches">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">get_close_matches</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">word</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">possibilities</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">3</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">cutoff</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0.6</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.get_close_matches" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return a list of the best “good enough” matches. <em>word</em> is a sequence for which
|
||
close matches are desired (typically a string), and <em>possibilities</em> is a list of
|
||
sequences against which to match <em>word</em> (typically a list of strings).</p>
|
||
<p>Optional argument <em>n</em> (default <code class="docutils literal notranslate"><span class="pre">3</span></code>) is the maximum number of close matches to
|
||
return; <em>n</em> must be greater than <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p>
|
||
<p>Optional argument <em>cutoff</em> (default <code class="docutils literal notranslate"><span class="pre">0.6</span></code>) is a float in the range [0, 1].
|
||
Possibilities that don’t score at least that similar to <em>word</em> are ignored.</p>
|
||
<p>The best (no more than <em>n</em>) matches among the possibilities are returned in a
|
||
list, sorted by similarity score, most similar first.</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">get_close_matches</span><span class="p">(</span><span class="s1">'appel'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'ape'</span><span class="p">,</span> <span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'peach'</span><span class="p">,</span> <span class="s1">'puppy'</span><span class="p">])</span>
|
||
<span class="go">['apple', 'ape']</span>
|
||
<span class="gp">>>> </span><span class="kn">import</span><span class="w"> </span><span class="nn">keyword</span>
|
||
<span class="gp">>>> </span><span class="n">get_close_matches</span><span class="p">(</span><span class="s1">'wheel'</span><span class="p">,</span> <span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span><span class="p">)</span>
|
||
<span class="go">['while']</span>
|
||
<span class="gp">>>> </span><span class="n">get_close_matches</span><span class="p">(</span><span class="s1">'pineapple'</span><span class="p">,</span> <span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span><span class="p">)</span>
|
||
<span class="go">[]</span>
|
||
<span class="gp">>>> </span><span class="n">get_close_matches</span><span class="p">(</span><span class="s1">'accept'</span><span class="p">,</span> <span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span><span class="p">)</span>
|
||
<span class="go">['except']</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.ndiff">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">ndiff</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">linejunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">charjunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">IS_CHARACTER_JUNK</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.ndiff" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compare <em>a</em> and <em>b</em> (lists of strings); return a <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a>-style
|
||
delta (a <a class="reference internal" href="../glossary.html#term-generator"><span class="xref std std-term">generator</span></a> generating the delta lines).</p>
|
||
<p>Optional keyword parameters <em>linejunk</em> and <em>charjunk</em> are filtering functions
|
||
(or <code class="docutils literal notranslate"><span class="pre">None</span></code>):</p>
|
||
<p><em>linejunk</em>: A function that accepts a single string argument, and returns
|
||
true if the string is junk, or false if not. The default is <code class="docutils literal notranslate"><span class="pre">None</span></code>. There
|
||
is also a module-level function <a class="reference internal" href="#difflib.IS_LINE_JUNK" title="difflib.IS_LINE_JUNK"><code class="xref py py-func docutils literal notranslate"><span class="pre">IS_LINE_JUNK()</span></code></a>, which filters out lines
|
||
without visible characters, except for at most one pound character (<code class="docutils literal notranslate"><span class="pre">'#'</span></code>)
|
||
– however the underlying <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> class does a dynamic
|
||
analysis of which lines are so frequent as to constitute noise, and this
|
||
usually works better than using this function.</p>
|
||
<p><em>charjunk</em>: A function that accepts a character (a string of length 1), and
|
||
returns if the character is junk, or false if not. The default is module-level
|
||
function <a class="reference internal" href="#difflib.IS_CHARACTER_JUNK" title="difflib.IS_CHARACTER_JUNK"><code class="xref py py-func docutils literal notranslate"><span class="pre">IS_CHARACTER_JUNK()</span></code></a>, which filters out whitespace characters (a
|
||
blank or tab; it’s a bad idea to include newline in this!).</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">diff</span> <span class="o">=</span> <span class="n">ndiff</span><span class="p">(</span><span class="s1">'one</span><span class="se">\n</span><span class="s1">two</span><span class="se">\n</span><span class="s1">three</span><span class="se">\n</span><span class="s1">'</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="s1">'ore</span><span class="se">\n</span><span class="s1">tree</span><span class="se">\n</span><span class="s1">emu</span><span class="se">\n</span><span class="s1">'</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">diff</span><span class="p">),</span> <span class="n">end</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
|
||
<span class="go">- one</span>
|
||
<span class="go">? ^</span>
|
||
<span class="go">+ ore</span>
|
||
<span class="go">? ^</span>
|
||
<span class="go">- two</span>
|
||
<span class="go">- three</span>
|
||
<span class="go">? -</span>
|
||
<span class="go">+ tree</span>
|
||
<span class="go">+ emu</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.restore">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">restore</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">sequence</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">which</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.restore" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return one of the two sequences that generated a delta.</p>
|
||
<p>Given a <em>sequence</em> produced by <a class="reference internal" href="#difflib.Differ.compare" title="difflib.Differ.compare"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Differ.compare()</span></code></a> or <a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">ndiff()</span></code></a>, extract
|
||
lines originating from file 1 or 2 (parameter <em>which</em>), stripping off line
|
||
prefixes.</p>
|
||
<p>Example:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">diff</span> <span class="o">=</span> <span class="n">ndiff</span><span class="p">(</span><span class="s1">'one</span><span class="se">\n</span><span class="s1">two</span><span class="se">\n</span><span class="s1">three</span><span class="se">\n</span><span class="s1">'</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="s1">'ore</span><span class="se">\n</span><span class="s1">tree</span><span class="se">\n</span><span class="s1">emu</span><span class="se">\n</span><span class="s1">'</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
|
||
<span class="gp">>>> </span><span class="n">diff</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">diff</span><span class="p">)</span> <span class="c1"># materialize the generated delta into a list</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">restore</span><span class="p">(</span><span class="n">diff</span><span class="p">,</span> <span class="mi">1</span><span class="p">)),</span> <span class="n">end</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
|
||
<span class="go">one</span>
|
||
<span class="go">two</span>
|
||
<span class="go">three</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">restore</span><span class="p">(</span><span class="n">diff</span><span class="p">,</span> <span class="mi">2</span><span class="p">)),</span> <span class="n">end</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
|
||
<span class="go">ore</span>
|
||
<span class="go">tree</span>
|
||
<span class="go">emu</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.unified_diff">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">unified_diff</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">3</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">lineterm</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'\n'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.unified_diff" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compare <em>a</em> and <em>b</em> (lists of strings); return a delta (a <a class="reference internal" href="../glossary.html#term-generator"><span class="xref std std-term">generator</span></a>
|
||
generating the delta lines) in unified diff format.</p>
|
||
<p>Unified diffs are a compact way of showing just the lines that have changed plus
|
||
a few lines of context. The changes are shown in an inline style (instead of
|
||
separate before/after blocks). The number of context lines is set by <em>n</em> which
|
||
defaults to three.</p>
|
||
<p>By default, the diff control lines (those with <code class="docutils literal notranslate"><span class="pre">---</span></code>, <code class="docutils literal notranslate"><span class="pre">+++</span></code>, or <code class="docutils literal notranslate"><span class="pre">@@</span></code>) are
|
||
created with a trailing newline. This is helpful so that inputs created from
|
||
<a class="reference internal" href="io.html#io.IOBase.readlines" title="io.IOBase.readlines"><code class="xref py py-func docutils literal notranslate"><span class="pre">io.IOBase.readlines()</span></code></a> result in diffs that are suitable for use with
|
||
<a class="reference internal" href="io.html#io.IOBase.writelines" title="io.IOBase.writelines"><code class="xref py py-func docutils literal notranslate"><span class="pre">io.IOBase.writelines()</span></code></a> since both the inputs and outputs have trailing
|
||
newlines.</p>
|
||
<p>For inputs that do not have trailing newlines, set the <em>lineterm</em> argument to
|
||
<code class="docutils literal notranslate"><span class="pre">""</span></code> so that the output will be uniformly newline free.</p>
|
||
<p>The unified diff format normally has a header for filenames and modification
|
||
times. Any or all of these may be specified using strings for <em>fromfile</em>,
|
||
<em>tofile</em>, <em>fromfiledate</em>, and <em>tofiledate</em>. The modification times are normally
|
||
expressed in the ISO 8601 format. If not specified, the
|
||
strings default to blanks.</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s1</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'bacon</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'eggs</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'ham</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'guido</span><span class="se">\n</span><span class="s1">'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">s2</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'python</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'eggy</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'hamster</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="s1">'guido</span><span class="se">\n</span><span class="s1">'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">writelines</span><span class="p">(</span><span class="n">unified_diff</span><span class="p">(</span><span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">,</span> <span class="n">fromfile</span><span class="o">=</span><span class="s1">'before.py'</span><span class="p">,</span> <span class="n">tofile</span><span class="o">=</span><span class="s1">'after.py'</span><span class="p">))</span>
|
||
<span class="go">--- before.py</span>
|
||
<span class="go">+++ after.py</span>
|
||
<span class="go">@@ -1,4 +1,4 @@</span>
|
||
<span class="go">-bacon</span>
|
||
<span class="go">-eggs</span>
|
||
<span class="go">-ham</span>
|
||
<span class="go">+python</span>
|
||
<span class="go">+eggy</span>
|
||
<span class="go">+hamster</span>
|
||
<span class="go"> guido</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>See <a class="reference internal" href="#difflib-interface"><span class="std std-ref">A command-line interface to difflib</span></a> for a more detailed example.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.diff_bytes">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">diff_bytes</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dfunc</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofile</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">fromfiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tofiledate</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">3</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">lineterm</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b'\n'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.diff_bytes" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compare <em>a</em> and <em>b</em> (lists of bytes objects) using <em>dfunc</em>; yield a
|
||
sequence of delta lines (also bytes) in the format returned by <em>dfunc</em>.
|
||
<em>dfunc</em> must be a callable, typically either <a class="reference internal" href="#difflib.unified_diff" title="difflib.unified_diff"><code class="xref py py-func docutils literal notranslate"><span class="pre">unified_diff()</span></code></a> or
|
||
<a class="reference internal" href="#difflib.context_diff" title="difflib.context_diff"><code class="xref py py-func docutils literal notranslate"><span class="pre">context_diff()</span></code></a>.</p>
|
||
<p>Allows you to compare data with unknown or inconsistent encoding. All
|
||
inputs except <em>n</em> must be bytes objects, not str. Works by losslessly
|
||
converting all inputs (except <em>n</em>) to str, and calling <code class="docutils literal notranslate"><span class="pre">dfunc(a,</span> <span class="pre">b,</span>
|
||
<span class="pre">fromfile,</span> <span class="pre">tofile,</span> <span class="pre">fromfiledate,</span> <span class="pre">tofiledate,</span> <span class="pre">n,</span> <span class="pre">lineterm)</span></code>. The output of
|
||
<em>dfunc</em> is then converted back to bytes, so the delta lines that you
|
||
receive have the same unknown/inconsistent encodings as <em>a</em> and <em>b</em>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.5.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.IS_LINE_JUNK">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">IS_LINE_JUNK</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">line</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.IS_LINE_JUNK" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return <code class="docutils literal notranslate"><span class="pre">True</span></code> for ignorable lines. The line <em>line</em> is ignorable if <em>line</em> is
|
||
blank or contains a single <code class="docutils literal notranslate"><span class="pre">'#'</span></code>, otherwise it is not ignorable. Used as a
|
||
default for parameter <em>linejunk</em> in <a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">ndiff()</span></code></a> in older versions.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="difflib.IS_CHARACTER_JUNK">
|
||
<span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">IS_CHARACTER_JUNK</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">ch</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.IS_CHARACTER_JUNK" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return <code class="docutils literal notranslate"><span class="pre">True</span></code> for ignorable characters. The character <em>ch</em> is ignorable if <em>ch</em>
|
||
is a space or tab, otherwise it is not ignorable. Used as a default for
|
||
parameter <em>charjunk</em> in <a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">ndiff()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<dl class="simple">
|
||
<dt><a class="reference external" href="https://www.drdobbs.com/database/pattern-matching-the-gestalt-approach/184407970">Pattern Matching: The Gestalt Approach</a></dt><dd><p>Discussion of a similar algorithm by John W. Ratcliff and D. E. Metzener. This
|
||
was published in <a class="reference external" href="https://www.drdobbs.com/">Dr. Dobb’s Journal</a> in July, 1988.</p>
|
||
</dd>
|
||
</dl>
|
||
</div>
|
||
<section id="sequencematcher-objects">
|
||
<span id="sequence-matcher"></span><h2>SequenceMatcher Objects<a class="headerlink" href="#sequencematcher-objects" title="Link to this heading">¶</a></h2>
|
||
<p>The <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> class has this constructor:</p>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">SequenceMatcher</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">isjunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">a</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">autojunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Optional argument <em>isjunk</em> must be <code class="docutils literal notranslate"><span class="pre">None</span></code> (the default) or a one-argument
|
||
function that takes a sequence element and returns true if and only if the
|
||
element is “junk” and should be ignored. Passing <code class="docutils literal notranslate"><span class="pre">None</span></code> for <em>isjunk</em> is
|
||
equivalent to passing <code class="docutils literal notranslate"><span class="pre">lambda</span> <span class="pre">x:</span> <span class="pre">False</span></code>; in other words, no elements are ignored.
|
||
For example, pass:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="ow">in</span> <span class="s2">" </span><span class="se">\t</span><span class="s2">"</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>if you’re comparing lines as sequences of characters, and don’t want to synch up
|
||
on blanks or hard tabs.</p>
|
||
<p>The optional arguments <em>a</em> and <em>b</em> are sequences to be compared; both default to
|
||
empty strings. The elements of both sequences must be <a class="reference internal" href="../glossary.html#term-hashable"><span class="xref std std-term">hashable</span></a>.</p>
|
||
<p>The optional argument <em>autojunk</em> can be used to disable the automatic junk
|
||
heuristic.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Added the <em>autojunk</em> parameter.</p>
|
||
</div>
|
||
<p>SequenceMatcher objects get three data attributes: <em>bjunk</em> is the
|
||
set of elements of <em>b</em> for which <em>isjunk</em> is <code class="docutils literal notranslate"><span class="pre">True</span></code>; <em>bpopular</em> is the set of
|
||
non-junk elements considered popular by the heuristic (if it is not
|
||
disabled); <em>b2j</em> is a dict mapping the remaining elements of <em>b</em> to a list
|
||
of positions where they occur. All three are reset whenever <em>b</em> is reset
|
||
with <a class="reference internal" href="#difflib.SequenceMatcher.set_seqs" title="difflib.SequenceMatcher.set_seqs"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_seqs()</span></code></a> or <a class="reference internal" href="#difflib.SequenceMatcher.set_seq2" title="difflib.SequenceMatcher.set_seq2"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_seq2()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.2: </span>The <em>bjunk</em> and <em>bpopular</em> attributes.</p>
|
||
</div>
|
||
<p><a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> objects have the following methods:</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.set_seqs">
|
||
<span class="sig-name descname"><span class="pre">set_seqs</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.set_seqs" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Set the two sequences to be compared.</p>
|
||
</dd></dl>
|
||
|
||
<p><a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> computes and caches detailed information about the
|
||
second sequence, so if you want to compare one sequence against many
|
||
sequences, use <a class="reference internal" href="#difflib.SequenceMatcher.set_seq2" title="difflib.SequenceMatcher.set_seq2"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_seq2()</span></code></a> to set the commonly used sequence once and
|
||
call <a class="reference internal" href="#difflib.SequenceMatcher.set_seq1" title="difflib.SequenceMatcher.set_seq1"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_seq1()</span></code></a> repeatedly, once for each of the other sequences.</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.set_seq1">
|
||
<span class="sig-name descname"><span class="pre">set_seq1</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.set_seq1" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Set the first sequence to be compared. The second sequence to be compared
|
||
is not changed.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.set_seq2">
|
||
<span class="sig-name descname"><span class="pre">set_seq2</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">b</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.set_seq2" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Set the second sequence to be compared. The first sequence to be compared
|
||
is not changed.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.find_longest_match">
|
||
<span class="sig-name descname"><span class="pre">find_longest_match</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">alo</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ahi</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">blo</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">bhi</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.find_longest_match" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Find longest matching block in <code class="docutils literal notranslate"><span class="pre">a[alo:ahi]</span></code> and <code class="docutils literal notranslate"><span class="pre">b[blo:bhi]</span></code>.</p>
|
||
<p>If <em>isjunk</em> was omitted or <code class="docutils literal notranslate"><span class="pre">None</span></code>, <a class="reference internal" href="#difflib.SequenceMatcher.find_longest_match" title="difflib.SequenceMatcher.find_longest_match"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_longest_match()</span></code></a> returns
|
||
<code class="docutils literal notranslate"><span class="pre">(i,</span> <span class="pre">j,</span> <span class="pre">k)</span></code> such that <code class="docutils literal notranslate"><span class="pre">a[i:i+k]</span></code> is equal to <code class="docutils literal notranslate"><span class="pre">b[j:j+k]</span></code>, where <code class="docutils literal notranslate"><span class="pre">alo</span>
|
||
<span class="pre"><=</span> <span class="pre">i</span> <span class="pre"><=</span> <span class="pre">i+k</span> <span class="pre"><=</span> <span class="pre">ahi</span></code> and <code class="docutils literal notranslate"><span class="pre">blo</span> <span class="pre"><=</span> <span class="pre">j</span> <span class="pre"><=</span> <span class="pre">j+k</span> <span class="pre"><=</span> <span class="pre">bhi</span></code>. For all <code class="docutils literal notranslate"><span class="pre">(i',</span> <span class="pre">j',</span>
|
||
<span class="pre">k')</span></code> meeting those conditions, the additional conditions <code class="docutils literal notranslate"><span class="pre">k</span> <span class="pre">>=</span> <span class="pre">k'</span></code>, <code class="docutils literal notranslate"><span class="pre">i</span>
|
||
<span class="pre"><=</span> <span class="pre">i'</span></code>, and if <code class="docutils literal notranslate"><span class="pre">i</span> <span class="pre">==</span> <span class="pre">i'</span></code>, <code class="docutils literal notranslate"><span class="pre">j</span> <span class="pre"><=</span> <span class="pre">j'</span></code> are also met. In other words, of
|
||
all maximal matching blocks, return one that starts earliest in <em>a</em>, and
|
||
of all those maximal matching blocks that start earliest in <em>a</em>, return
|
||
the one that starts earliest in <em>b</em>.</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="s2">" abcd"</span><span class="p">,</span> <span class="s2">"abcd abcd"</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">find_longest_match</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">9</span><span class="p">)</span>
|
||
<span class="go">Match(a=0, b=4, size=5)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If <em>isjunk</em> was provided, first the longest matching block is determined
|
||
as above, but with the additional restriction that no junk element appears
|
||
in the block. Then that block is extended as far as possible by matching
|
||
(only) junk elements on both sides. So the resulting block never matches
|
||
on junk except as identical junk happens to be adjacent to an interesting
|
||
match.</p>
|
||
<p>Here’s the same example as before, but considering blanks to be junk. That
|
||
prevents <code class="docutils literal notranslate"><span class="pre">'</span> <span class="pre">abcd'</span></code> from matching the <code class="docutils literal notranslate"><span class="pre">'</span> <span class="pre">abcd'</span></code> at the tail end of the
|
||
second sequence directly. Instead only the <code class="docutils literal notranslate"><span class="pre">'abcd'</span></code> can match, and
|
||
matches the leftmost <code class="docutils literal notranslate"><span class="pre">'abcd'</span></code> in the second sequence:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">==</span><span class="s2">" "</span><span class="p">,</span> <span class="s2">" abcd"</span><span class="p">,</span> <span class="s2">"abcd abcd"</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">find_longest_match</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">9</span><span class="p">)</span>
|
||
<span class="go">Match(a=1, b=0, size=4)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If no blocks match, this returns <code class="docutils literal notranslate"><span class="pre">(alo,</span> <span class="pre">blo,</span> <span class="pre">0)</span></code>.</p>
|
||
<p>This method returns a <a class="reference internal" href="../glossary.html#term-named-tuple"><span class="xref std std-term">named tuple</span></a> <code class="docutils literal notranslate"><span class="pre">Match(a,</span> <span class="pre">b,</span> <span class="pre">size)</span></code>.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.9: </span>Added default arguments.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.get_matching_blocks">
|
||
<span class="sig-name descname"><span class="pre">get_matching_blocks</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.get_matching_blocks" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return list of triples describing non-overlapping matching subsequences.
|
||
Each triple is of the form <code class="docutils literal notranslate"><span class="pre">(i,</span> <span class="pre">j,</span> <span class="pre">n)</span></code>,
|
||
and means that <code class="docutils literal notranslate"><span class="pre">a[i:i+n]</span> <span class="pre">==</span> <span class="pre">b[j:j+n]</span></code>. The
|
||
triples are monotonically increasing in <em>i</em> and <em>j</em>.</p>
|
||
<p>The last triple is a dummy, and has the value <code class="docutils literal notranslate"><span class="pre">(len(a),</span> <span class="pre">len(b),</span> <span class="pre">0)</span></code>. It
|
||
is the only triple with <code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">==</span> <span class="pre">0</span></code>. If <code class="docutils literal notranslate"><span class="pre">(i,</span> <span class="pre">j,</span> <span class="pre">n)</span></code> and <code class="docutils literal notranslate"><span class="pre">(i',</span> <span class="pre">j',</span> <span class="pre">n')</span></code>
|
||
are adjacent triples in the list, and the second is not the last triple in
|
||
the list, then <code class="docutils literal notranslate"><span class="pre">i+n</span> <span class="pre"><</span> <span class="pre">i'</span></code> or <code class="docutils literal notranslate"><span class="pre">j+n</span> <span class="pre"><</span> <span class="pre">j'</span></code>; in other words, adjacent
|
||
triples always describe non-adjacent equal blocks.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="s2">"abxcd"</span><span class="p">,</span> <span class="s2">"abcd"</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">get_matching_blocks</span><span class="p">()</span>
|
||
<span class="go">[Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.get_opcodes">
|
||
<span class="sig-name descname"><span class="pre">get_opcodes</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.get_opcodes" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return list of 5-tuples describing how to turn <em>a</em> into <em>b</em>. Each tuple is
|
||
of the form <code class="docutils literal notranslate"><span class="pre">(tag,</span> <span class="pre">i1,</span> <span class="pre">i2,</span> <span class="pre">j1,</span> <span class="pre">j2)</span></code>. The first tuple has <code class="docutils literal notranslate"><span class="pre">i1</span> <span class="pre">==</span> <span class="pre">j1</span> <span class="pre">==</span>
|
||
<span class="pre">0</span></code>, and remaining tuples have <em>i1</em> equal to the <em>i2</em> from the preceding
|
||
tuple, and, likewise, <em>j1</em> equal to the previous <em>j2</em>.</p>
|
||
<p>The <em>tag</em> values are strings, with these meanings:</p>
|
||
<table class="docutils align-default">
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>Value</p></th>
|
||
<th class="head"><p>Meaning</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">'replace'</span></code></p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">a[i1:i2]</span></code> should be replaced by
|
||
<code class="docutils literal notranslate"><span class="pre">b[j1:j2]</span></code>.</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">'delete'</span></code></p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">a[i1:i2]</span></code> should be deleted. Note that
|
||
<code class="docutils literal notranslate"><span class="pre">j1</span> <span class="pre">==</span> <span class="pre">j2</span></code> in this case.</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">'insert'</span></code></p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">b[j1:j2]</span></code> should be inserted at
|
||
<code class="docutils literal notranslate"><span class="pre">a[i1:i1]</span></code>. Note that <code class="docutils literal notranslate"><span class="pre">i1</span> <span class="pre">==</span> <span class="pre">i2</span></code> in
|
||
this case.</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">'equal'</span></code></p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">a[i1:i2]</span> <span class="pre">==</span> <span class="pre">b[j1:j2]</span></code> (the sub-sequences
|
||
are equal).</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<p>For example:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="s2">"qabxcd"</span>
|
||
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="s2">"abycdf"</span>
|
||
<span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">tag</span><span class="p">,</span> <span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">,</span> <span class="n">j1</span><span class="p">,</span> <span class="n">j2</span> <span class="ow">in</span> <span class="n">s</span><span class="o">.</span><span class="n">get_opcodes</span><span class="p">():</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s1">'</span><span class="si">{:7}</span><span class="s1"> a[</span><span class="si">{}</span><span class="s1">:</span><span class="si">{}</span><span class="s1">] --> b[</span><span class="si">{}</span><span class="s1">:</span><span class="si">{}</span><span class="s1">] </span><span class="si">{!r:>8}</span><span class="s1"> --> </span><span class="si">{!r}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
|
||
<span class="gp">... </span> <span class="n">tag</span><span class="p">,</span> <span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">,</span> <span class="n">j1</span><span class="p">,</span> <span class="n">j2</span><span class="p">,</span> <span class="n">a</span><span class="p">[</span><span class="n">i1</span><span class="p">:</span><span class="n">i2</span><span class="p">],</span> <span class="n">b</span><span class="p">[</span><span class="n">j1</span><span class="p">:</span><span class="n">j2</span><span class="p">]))</span>
|
||
<span class="go">delete a[0:1] --> b[0:0] 'q' --> ''</span>
|
||
<span class="go">equal a[1:3] --> b[0:2] 'ab' --> 'ab'</span>
|
||
<span class="go">replace a[3:4] --> b[2:3] 'x' --> 'y'</span>
|
||
<span class="go">equal a[4:6] --> b[3:5] 'cd' --> 'cd'</span>
|
||
<span class="go">insert a[6:6] --> b[5:6] '' --> 'f'</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.get_grouped_opcodes">
|
||
<span class="sig-name descname"><span class="pre">get_grouped_opcodes</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">3</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.get_grouped_opcodes" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return a <a class="reference internal" href="../glossary.html#term-generator"><span class="xref std std-term">generator</span></a> of groups with up to <em>n</em> lines of context.</p>
|
||
<p>Starting with the groups returned by <a class="reference internal" href="#difflib.SequenceMatcher.get_opcodes" title="difflib.SequenceMatcher.get_opcodes"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_opcodes()</span></code></a>, this method
|
||
splits out smaller change clusters and eliminates intervening ranges which
|
||
have no changes.</p>
|
||
<p>The groups are returned in the same format as <a class="reference internal" href="#difflib.SequenceMatcher.get_opcodes" title="difflib.SequenceMatcher.get_opcodes"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_opcodes()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.ratio">
|
||
<span class="sig-name descname"><span class="pre">ratio</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.ratio" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return a measure of the sequences’ similarity as a float in the range [0,
|
||
1].</p>
|
||
<p>Where T is the total number of elements in both sequences, and M is the
|
||
number of matches, this is 2.0*M / T. Note that this is <code class="docutils literal notranslate"><span class="pre">1.0</span></code> if the
|
||
sequences are identical, and <code class="docutils literal notranslate"><span class="pre">0.0</span></code> if they have nothing in common.</p>
|
||
<p>This is expensive to compute if <a class="reference internal" href="#difflib.SequenceMatcher.get_matching_blocks" title="difflib.SequenceMatcher.get_matching_blocks"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_matching_blocks()</span></code></a> or
|
||
<a class="reference internal" href="#difflib.SequenceMatcher.get_opcodes" title="difflib.SequenceMatcher.get_opcodes"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_opcodes()</span></code></a> hasn’t already been called, in which case you may want
|
||
to try <a class="reference internal" href="#difflib.SequenceMatcher.quick_ratio" title="difflib.SequenceMatcher.quick_ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">quick_ratio()</span></code></a> or <a class="reference internal" href="#difflib.SequenceMatcher.real_quick_ratio" title="difflib.SequenceMatcher.real_quick_ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">real_quick_ratio()</span></code></a> first to get an
|
||
upper bound.</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>Caution: The result of a <a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a> call may depend on the order of
|
||
the arguments. For instance:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="s1">'tide'</span><span class="p">,</span> <span class="s1">'diet'</span><span class="p">)</span><span class="o">.</span><span class="n">ratio</span><span class="p">()</span>
|
||
<span class="go">0.25</span>
|
||
<span class="gp">>>> </span><span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="s1">'diet'</span><span class="p">,</span> <span class="s1">'tide'</span><span class="p">)</span><span class="o">.</span><span class="n">ratio</span><span class="p">()</span>
|
||
<span class="go">0.5</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.quick_ratio">
|
||
<span class="sig-name descname"><span class="pre">quick_ratio</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.quick_ratio" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return an upper bound on <a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a> relatively quickly.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.SequenceMatcher.real_quick_ratio">
|
||
<span class="sig-name descname"><span class="pre">real_quick_ratio</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#difflib.SequenceMatcher.real_quick_ratio" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return an upper bound on <a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a> very quickly.</p>
|
||
</dd></dl>
|
||
|
||
</dd></dl>
|
||
|
||
<p>The three methods that return the ratio of matching to total characters can give
|
||
different results due to differing levels of approximation, although
|
||
<a class="reference internal" href="#difflib.SequenceMatcher.quick_ratio" title="difflib.SequenceMatcher.quick_ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">quick_ratio()</span></code></a> and <a class="reference internal" href="#difflib.SequenceMatcher.real_quick_ratio" title="difflib.SequenceMatcher.real_quick_ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">real_quick_ratio()</span></code></a>
|
||
are always at least as large as <a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a>:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="s2">"abcd"</span><span class="p">,</span> <span class="s2">"bcde"</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">ratio</span><span class="p">()</span>
|
||
<span class="go">0.75</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">quick_ratio</span><span class="p">()</span>
|
||
<span class="go">0.75</span>
|
||
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">real_quick_ratio</span><span class="p">()</span>
|
||
<span class="go">1.0</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="sequencematcher-examples">
|
||
<span id="id1"></span><h2>SequenceMatcher Examples<a class="headerlink" href="#sequencematcher-examples" title="Link to this heading">¶</a></h2>
|
||
<p>This example compares two strings, considering blanks to be “junk”:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">SequenceMatcher</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">==</span> <span class="s2">" "</span><span class="p">,</span>
|
||
<span class="gp">... </span> <span class="s2">"private Thread currentThread;"</span><span class="p">,</span>
|
||
<span class="gp">... </span> <span class="s2">"private volatile Thread currentThread;"</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a> returns a float in [0, 1], measuring the similarity of the
|
||
sequences. As a rule of thumb, a <a class="reference internal" href="#difflib.SequenceMatcher.ratio" title="difflib.SequenceMatcher.ratio"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ratio()</span></code></a> value over 0.6 means the
|
||
sequences are close matches:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="nb">round</span><span class="p">(</span><span class="n">s</span><span class="o">.</span><span class="n">ratio</span><span class="p">(),</span> <span class="mi">3</span><span class="p">))</span>
|
||
<span class="go">0.866</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If you’re only interested in where the sequences match,
|
||
<a class="reference internal" href="#difflib.SequenceMatcher.get_matching_blocks" title="difflib.SequenceMatcher.get_matching_blocks"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_matching_blocks()</span></code></a> is handy:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">block</span> <span class="ow">in</span> <span class="n">s</span><span class="o">.</span><span class="n">get_matching_blocks</span><span class="p">():</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s2">"a[</span><span class="si">%d</span><span class="s2">] and b[</span><span class="si">%d</span><span class="s2">] match for </span><span class="si">%d</span><span class="s2"> elements"</span> <span class="o">%</span> <span class="n">block</span><span class="p">)</span>
|
||
<span class="go">a[0] and b[0] match for 8 elements</span>
|
||
<span class="go">a[8] and b[17] match for 21 elements</span>
|
||
<span class="go">a[29] and b[38] match for 0 elements</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Note that the last tuple returned by <a class="reference internal" href="#difflib.SequenceMatcher.get_matching_blocks" title="difflib.SequenceMatcher.get_matching_blocks"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_matching_blocks()</span></code></a>
|
||
is always a dummy, <code class="docutils literal notranslate"><span class="pre">(len(a),</span> <span class="pre">len(b),</span> <span class="pre">0)</span></code>, and this is the only case in which the last
|
||
tuple element (number of elements matched) is <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p>
|
||
<p>If you want to know how to change the first sequence into the second, use
|
||
<a class="reference internal" href="#difflib.SequenceMatcher.get_opcodes" title="difflib.SequenceMatcher.get_opcodes"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_opcodes()</span></code></a>:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">opcode</span> <span class="ow">in</span> <span class="n">s</span><span class="o">.</span><span class="n">get_opcodes</span><span class="p">():</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">%6s</span><span class="s2"> a[</span><span class="si">%d</span><span class="s2">:</span><span class="si">%d</span><span class="s2">] b[</span><span class="si">%d</span><span class="s2">:</span><span class="si">%d</span><span class="s2">]"</span> <span class="o">%</span> <span class="n">opcode</span><span class="p">)</span>
|
||
<span class="go"> equal a[0:8] b[0:8]</span>
|
||
<span class="go">insert a[8:8] b[8:17]</span>
|
||
<span class="go"> equal a[8:29] b[17:38]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<ul class="simple">
|
||
<li><p>The <a class="reference internal" href="#difflib.get_close_matches" title="difflib.get_close_matches"><code class="xref py py-func docutils literal notranslate"><span class="pre">get_close_matches()</span></code></a> function in this module which shows how
|
||
simple code building on <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a> can be used to do useful
|
||
work.</p></li>
|
||
<li><p><a class="reference external" href="https://code.activestate.com/recipes/576729-simple-version-control/">Simple version control recipe</a> for a small application
|
||
built with <a class="reference internal" href="#difflib.SequenceMatcher" title="difflib.SequenceMatcher"><code class="xref py py-class docutils literal notranslate"><span class="pre">SequenceMatcher</span></code></a>.</p></li>
|
||
</ul>
|
||
</div>
|
||
</section>
|
||
<section id="differ-objects">
|
||
<span id="id2"></span><h2>Differ Objects<a class="headerlink" href="#differ-objects" title="Link to this heading">¶</a></h2>
|
||
<p>Note that <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a>-generated deltas make no claim to be <strong>minimal</strong>
|
||
diffs. To the contrary, minimal diffs are often counter-intuitive, because they
|
||
synch up anywhere possible, sometimes accidental matches 100 pages apart.
|
||
Restricting synch points to contiguous matches preserves some notion of
|
||
locality, at the occasional cost of producing a longer diff.</p>
|
||
<p>The <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a> class has this constructor:</p>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">difflib.</span></span><span class="sig-name descname"><span class="pre">Differ</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">linejunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">charjunk</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span></dt>
|
||
<dd><p>Optional keyword parameters <em>linejunk</em> and <em>charjunk</em> are for filter functions
|
||
(or <code class="docutils literal notranslate"><span class="pre">None</span></code>):</p>
|
||
<p><em>linejunk</em>: A function that accepts a single string argument, and returns true
|
||
if the string is junk. The default is <code class="docutils literal notranslate"><span class="pre">None</span></code>, meaning that no line is
|
||
considered junk.</p>
|
||
<p><em>charjunk</em>: A function that accepts a single character argument (a string of
|
||
length 1), and returns true if the character is junk. The default is <code class="docutils literal notranslate"><span class="pre">None</span></code>,
|
||
meaning that no character is considered junk.</p>
|
||
<p>These junk-filtering functions speed up matching to find
|
||
differences and do not cause any differing lines or characters to
|
||
be ignored. Read the description of the
|
||
<a class="reference internal" href="#difflib.SequenceMatcher.find_longest_match" title="difflib.SequenceMatcher.find_longest_match"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_longest_match()</span></code></a> method’s <em>isjunk</em>
|
||
parameter for an explanation.</p>
|
||
<p><a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a> objects are used (deltas generated) via a single method:</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="difflib.Differ.compare">
|
||
<span class="sig-name descname"><span class="pre">compare</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#difflib.Differ.compare" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Compare two sequences of lines, and generate the delta (a sequence of lines).</p>
|
||
<p>Each sequence must contain individual single-line strings ending with
|
||
newlines. Such sequences can be obtained from the
|
||
<a class="reference internal" href="io.html#io.IOBase.readlines" title="io.IOBase.readlines"><code class="xref py py-meth docutils literal notranslate"><span class="pre">readlines()</span></code></a> method of file-like objects. The delta
|
||
generated also consists of newline-terminated strings, ready to be
|
||
printed as-is via the <a class="reference internal" href="io.html#io.IOBase.writelines" title="io.IOBase.writelines"><code class="xref py py-meth docutils literal notranslate"><span class="pre">writelines()</span></code></a> method of a
|
||
file-like object.</p>
|
||
</dd></dl>
|
||
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="differ-example">
|
||
<span id="differ-examples"></span><h2>Differ Example<a class="headerlink" href="#differ-example" title="Link to this heading">¶</a></h2>
|
||
<p>This example compares two texts. First we set up the texts, sequences of
|
||
individual single-line strings ending with newlines (such sequences can also be
|
||
obtained from the <a class="reference internal" href="io.html#io.IOBase.readlines" title="io.IOBase.readlines"><code class="xref py py-meth docutils literal notranslate"><span class="pre">readlines()</span></code></a> method of file-like objects):</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">text1</span> <span class="o">=</span> <span class="s1">''' 1. Beautiful is better than ugly.</span>
|
||
<span class="gp">... </span><span class="s1"> 2. Explicit is better than implicit.</span>
|
||
<span class="gp">... </span><span class="s1"> 3. Simple is better than complex.</span>
|
||
<span class="gp">... </span><span class="s1"> 4. Complex is better than complicated.</span>
|
||
<span class="gp">... </span><span class="s1">'''</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">text1</span><span class="p">)</span>
|
||
<span class="go">4</span>
|
||
<span class="gp">>>> </span><span class="n">text1</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
|
||
<span class="go">'\n'</span>
|
||
<span class="gp">>>> </span><span class="n">text2</span> <span class="o">=</span> <span class="s1">''' 1. Beautiful is better than ugly.</span>
|
||
<span class="gp">... </span><span class="s1"> 3. Simple is better than complex.</span>
|
||
<span class="gp">... </span><span class="s1"> 4. Complicated is better than complex.</span>
|
||
<span class="gp">... </span><span class="s1"> 5. Flat is better than nested.</span>
|
||
<span class="gp">... </span><span class="s1">'''</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Next we instantiate a Differ object:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="n">Differ</span><span class="p">()</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Note that when instantiating a <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-class docutils literal notranslate"><span class="pre">Differ</span></code></a> object we may pass functions to
|
||
filter out line and character “junk.” See the <a class="reference internal" href="#difflib.Differ" title="difflib.Differ"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Differ()</span></code></a> constructor for
|
||
details.</p>
|
||
<p>Finally, we compare the two:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">result</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">compare</span><span class="p">(</span><span class="n">text1</span><span class="p">,</span> <span class="n">text2</span><span class="p">))</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><code class="docutils literal notranslate"><span class="pre">result</span></code> is a list of strings, so let’s pretty-print it:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span><span class="w"> </span><span class="nn">pprint</span><span class="w"> </span><span class="kn">import</span> <span class="n">pprint</span>
|
||
<span class="gp">>>> </span><span class="n">pprint</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
|
||
<span class="go">[' 1. Beautiful is better than ugly.\n',</span>
|
||
<span class="go"> '- 2. Explicit is better than implicit.\n',</span>
|
||
<span class="go"> '- 3. Simple is better than complex.\n',</span>
|
||
<span class="go"> '+ 3. Simple is better than complex.\n',</span>
|
||
<span class="go"> '? ++\n',</span>
|
||
<span class="go"> '- 4. Complex is better than complicated.\n',</span>
|
||
<span class="go"> '? ^ ---- ^\n',</span>
|
||
<span class="go"> '+ 4. Complicated is better than complex.\n',</span>
|
||
<span class="go"> '? ++++ ^ ^\n',</span>
|
||
<span class="go"> '+ 5. Flat is better than nested.\n']</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>As a single multi-line string it looks like this:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span><span class="w"> </span><span class="nn">sys</span>
|
||
<span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">writelines</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
|
||
<span class="go"> 1. Beautiful is better than ugly.</span>
|
||
<span class="go">- 2. Explicit is better than implicit.</span>
|
||
<span class="go">- 3. Simple is better than complex.</span>
|
||
<span class="go">+ 3. Simple is better than complex.</span>
|
||
<span class="go">? ++</span>
|
||
<span class="go">- 4. Complex is better than complicated.</span>
|
||
<span class="go">? ^ ---- ^</span>
|
||
<span class="go">+ 4. Complicated is better than complex.</span>
|
||
<span class="go">? ++++ ^ ^</span>
|
||
<span class="go">+ 5. Flat is better than nested.</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="a-command-line-interface-to-difflib">
|
||
<span id="difflib-interface"></span><h2>A command-line interface to difflib<a class="headerlink" href="#a-command-line-interface-to-difflib" title="Link to this heading">¶</a></h2>
|
||
<p>This example shows how to use difflib to create a <code class="docutils literal notranslate"><span class="pre">diff</span></code>-like utility.</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="sd">""" Command line interface to difflib.py providing diffs in four formats:</span>
|
||
|
||
<span class="sd">* ndiff: lists every line and highlights interline changes.</span>
|
||
<span class="sd">* context: highlights clusters of changes in a before/after format.</span>
|
||
<span class="sd">* unified: highlights clusters of changes in an inline format.</span>
|
||
<span class="sd">* html: generates side by side comparison with change highlights.</span>
|
||
|
||
<span class="sd">"""</span>
|
||
|
||
<span class="kn">import</span><span class="w"> </span><span class="nn">sys</span><span class="o">,</span><span class="w"> </span><span class="nn">os</span><span class="o">,</span><span class="w"> </span><span class="nn">difflib</span><span class="o">,</span><span class="w"> </span><span class="nn">argparse</span>
|
||
<span class="kn">from</span><span class="w"> </span><span class="nn">datetime</span><span class="w"> </span><span class="kn">import</span> <span class="n">datetime</span><span class="p">,</span> <span class="n">timezone</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">file_mtime</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
|
||
<span class="n">t</span> <span class="o">=</span> <span class="n">datetime</span><span class="o">.</span><span class="n">fromtimestamp</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">stat</span><span class="p">(</span><span class="n">path</span><span class="p">)</span><span class="o">.</span><span class="n">st_mtime</span><span class="p">,</span>
|
||
<span class="n">timezone</span><span class="o">.</span><span class="n">utc</span><span class="p">)</span>
|
||
<span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">astimezone</span><span class="p">()</span><span class="o">.</span><span class="n">isoformat</span><span class="p">()</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">main</span><span class="p">():</span>
|
||
|
||
<span class="n">parser</span> <span class="o">=</span> <span class="n">argparse</span><span class="o">.</span><span class="n">ArgumentParser</span><span class="p">()</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'-c'</span><span class="p">,</span> <span class="n">action</span><span class="o">=</span><span class="s1">'store_true'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
|
||
<span class="n">help</span><span class="o">=</span><span class="s1">'Produce a context format diff (default)'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'-u'</span><span class="p">,</span> <span class="n">action</span><span class="o">=</span><span class="s1">'store_true'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
|
||
<span class="n">help</span><span class="o">=</span><span class="s1">'Produce a unified format diff'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'-m'</span><span class="p">,</span> <span class="n">action</span><span class="o">=</span><span class="s1">'store_true'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
|
||
<span class="n">help</span><span class="o">=</span><span class="s1">'Produce HTML side by side diff '</span>
|
||
<span class="s1">'(can use -c and -l in conjunction)'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'-n'</span><span class="p">,</span> <span class="n">action</span><span class="o">=</span><span class="s1">'store_true'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
|
||
<span class="n">help</span><span class="o">=</span><span class="s1">'Produce a ndiff format diff'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'-l'</span><span class="p">,</span> <span class="s1">'--lines'</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="nb">int</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span>
|
||
<span class="n">help</span><span class="o">=</span><span class="s1">'Set number of context lines (default 3)'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'fromfile'</span><span class="p">)</span>
|
||
<span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">'tofile'</span><span class="p">)</span>
|
||
<span class="n">options</span> <span class="o">=</span> <span class="n">parser</span><span class="o">.</span><span class="n">parse_args</span><span class="p">()</span>
|
||
|
||
<span class="n">n</span> <span class="o">=</span> <span class="n">options</span><span class="o">.</span><span class="n">lines</span>
|
||
<span class="n">fromfile</span> <span class="o">=</span> <span class="n">options</span><span class="o">.</span><span class="n">fromfile</span>
|
||
<span class="n">tofile</span> <span class="o">=</span> <span class="n">options</span><span class="o">.</span><span class="n">tofile</span>
|
||
|
||
<span class="n">fromdate</span> <span class="o">=</span> <span class="n">file_mtime</span><span class="p">(</span><span class="n">fromfile</span><span class="p">)</span>
|
||
<span class="n">todate</span> <span class="o">=</span> <span class="n">file_mtime</span><span class="p">(</span><span class="n">tofile</span><span class="p">)</span>
|
||
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">fromfile</span><span class="p">)</span> <span class="k">as</span> <span class="n">ff</span><span class="p">:</span>
|
||
<span class="n">fromlines</span> <span class="o">=</span> <span class="n">ff</span><span class="o">.</span><span class="n">readlines</span><span class="p">()</span>
|
||
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">tofile</span><span class="p">)</span> <span class="k">as</span> <span class="n">tf</span><span class="p">:</span>
|
||
<span class="n">tolines</span> <span class="o">=</span> <span class="n">tf</span><span class="o">.</span><span class="n">readlines</span><span class="p">()</span>
|
||
|
||
<span class="k">if</span> <span class="n">options</span><span class="o">.</span><span class="n">u</span><span class="p">:</span>
|
||
<span class="n">diff</span> <span class="o">=</span> <span class="n">difflib</span><span class="o">.</span><span class="n">unified_diff</span><span class="p">(</span><span class="n">fromlines</span><span class="p">,</span> <span class="n">tolines</span><span class="p">,</span> <span class="n">fromfile</span><span class="p">,</span> <span class="n">tofile</span><span class="p">,</span> <span class="n">fromdate</span><span class="p">,</span> <span class="n">todate</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="n">n</span><span class="p">)</span>
|
||
<span class="k">elif</span> <span class="n">options</span><span class="o">.</span><span class="n">n</span><span class="p">:</span>
|
||
<span class="n">diff</span> <span class="o">=</span> <span class="n">difflib</span><span class="o">.</span><span class="n">ndiff</span><span class="p">(</span><span class="n">fromlines</span><span class="p">,</span> <span class="n">tolines</span><span class="p">)</span>
|
||
<span class="k">elif</span> <span class="n">options</span><span class="o">.</span><span class="n">m</span><span class="p">:</span>
|
||
<span class="n">diff</span> <span class="o">=</span> <span class="n">difflib</span><span class="o">.</span><span class="n">HtmlDiff</span><span class="p">()</span><span class="o">.</span><span class="n">make_file</span><span class="p">(</span><span class="n">fromlines</span><span class="p">,</span><span class="n">tolines</span><span class="p">,</span><span class="n">fromfile</span><span class="p">,</span><span class="n">tofile</span><span class="p">,</span><span class="n">context</span><span class="o">=</span><span class="n">options</span><span class="o">.</span><span class="n">c</span><span class="p">,</span><span class="n">numlines</span><span class="o">=</span><span class="n">n</span><span class="p">)</span>
|
||
<span class="k">else</span><span class="p">:</span>
|
||
<span class="n">diff</span> <span class="o">=</span> <span class="n">difflib</span><span class="o">.</span><span class="n">context_diff</span><span class="p">(</span><span class="n">fromlines</span><span class="p">,</span> <span class="n">tolines</span><span class="p">,</span> <span class="n">fromfile</span><span class="p">,</span> <span class="n">tofile</span><span class="p">,</span> <span class="n">fromdate</span><span class="p">,</span> <span class="n">todate</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="n">n</span><span class="p">)</span>
|
||
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">writelines</span><span class="p">(</span><span class="n">diff</span><span class="p">)</span>
|
||
|
||
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
|
||
<span class="n">main</span><span class="p">()</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="ndiff-example">
|
||
<h2>ndiff example<a class="headerlink" href="#ndiff-example" title="Link to this heading">¶</a></h2>
|
||
<p>This example shows how to use <a class="reference internal" href="#difflib.ndiff" title="difflib.ndiff"><code class="xref py py-func docutils literal notranslate"><span class="pre">difflib.ndiff()</span></code></a>.</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="sd">"""ndiff [-q] file1 file2</span>
|
||
<span class="sd"> or</span>
|
||
<span class="sd">ndiff (-r1 | -r2) < ndiff_output > file1_or_file2</span>
|
||
|
||
<span class="sd">Print a human-friendly file difference report to stdout. Both inter-</span>
|
||
<span class="sd">and intra-line differences are noted. In the second form, recreate file1</span>
|
||
<span class="sd">(-r1) or file2 (-r2) on stdout, from an ndiff report on stdin.</span>
|
||
|
||
<span class="sd">In the first form, if -q ("quiet") is not specified, the first two lines</span>
|
||
<span class="sd">of output are</span>
|
||
|
||
<span class="sd">-: file1</span>
|
||
<span class="sd">+: file2</span>
|
||
|
||
<span class="sd">Each remaining line begins with a two-letter code:</span>
|
||
|
||
<span class="sd"> "- " line unique to file1</span>
|
||
<span class="sd"> "+ " line unique to file2</span>
|
||
<span class="sd"> " " line common to both files</span>
|
||
<span class="sd"> "? " line not present in either input file</span>
|
||
|
||
<span class="sd">Lines beginning with "? " attempt to guide the eye to intraline</span>
|
||
<span class="sd">differences, and were not present in either input file. These lines can be</span>
|
||
<span class="sd">confusing if the source files contain tab characters.</span>
|
||
|
||
<span class="sd">The first file can be recovered by retaining only lines that begin with</span>
|
||
<span class="sd">" " or "- ", and deleting those 2-character prefixes; use ndiff with -r1.</span>
|
||
|
||
<span class="sd">The second file can be recovered similarly, but by retaining only " " and</span>
|
||
<span class="sd">"+ " lines; use ndiff with -r2; or, on Unix, the second file can be</span>
|
||
<span class="sd">recovered by piping the output through</span>
|
||
|
||
<span class="sd"> sed -n '/^[+ ] /s/^..//p'</span>
|
||
<span class="sd">"""</span>
|
||
|
||
<span class="n">__version__</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">0</span>
|
||
|
||
<span class="kn">import</span><span class="w"> </span><span class="nn">difflib</span><span class="o">,</span><span class="w"> </span><span class="nn">sys</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">fail</span><span class="p">(</span><span class="n">msg</span><span class="p">):</span>
|
||
<span class="n">out</span> <span class="o">=</span> <span class="n">sys</span><span class="o">.</span><span class="n">stderr</span><span class="o">.</span><span class="n">write</span>
|
||
<span class="n">out</span><span class="p">(</span><span class="n">msg</span> <span class="o">+</span> <span class="s2">"</span><span class="se">\n\n</span><span class="s2">"</span><span class="p">)</span>
|
||
<span class="n">out</span><span class="p">(</span><span class="vm">__doc__</span><span class="p">)</span>
|
||
<span class="k">return</span> <span class="mi">0</span>
|
||
|
||
<span class="c1"># open a file & return the file object; gripe and return 0 if it</span>
|
||
<span class="c1"># couldn't be opened</span>
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">fopen</span><span class="p">(</span><span class="n">fname</span><span class="p">):</span>
|
||
<span class="k">try</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="nb">open</span><span class="p">(</span><span class="n">fname</span><span class="p">)</span>
|
||
<span class="k">except</span> <span class="ne">IOError</span> <span class="k">as</span> <span class="n">detail</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="s2">"couldn't open "</span> <span class="o">+</span> <span class="n">fname</span> <span class="o">+</span> <span class="s2">": "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">detail</span><span class="p">))</span>
|
||
|
||
<span class="c1"># open two files & spray the diff to stdout; return false iff a problem</span>
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">fcompare</span><span class="p">(</span><span class="n">f1name</span><span class="p">,</span> <span class="n">f2name</span><span class="p">):</span>
|
||
<span class="n">f1</span> <span class="o">=</span> <span class="n">fopen</span><span class="p">(</span><span class="n">f1name</span><span class="p">)</span>
|
||
<span class="n">f2</span> <span class="o">=</span> <span class="n">fopen</span><span class="p">(</span><span class="n">f2name</span><span class="p">)</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">f1</span> <span class="ow">or</span> <span class="ow">not</span> <span class="n">f2</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="mi">0</span>
|
||
|
||
<span class="n">a</span> <span class="o">=</span> <span class="n">f1</span><span class="o">.</span><span class="n">readlines</span><span class="p">();</span> <span class="n">f1</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
|
||
<span class="n">b</span> <span class="o">=</span> <span class="n">f2</span><span class="o">.</span><span class="n">readlines</span><span class="p">();</span> <span class="n">f2</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
|
||
<span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">difflib</span><span class="o">.</span><span class="n">ndiff</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
|
||
<span class="nb">print</span><span class="p">(</span><span class="n">line</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s1">' '</span><span class="p">)</span>
|
||
|
||
<span class="k">return</span> <span class="mi">1</span>
|
||
|
||
<span class="c1"># crack args (sys.argv[1:] is normal) & compare;</span>
|
||
<span class="c1"># return false iff a problem</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="n">args</span><span class="p">):</span>
|
||
<span class="kn">import</span><span class="w"> </span><span class="nn">getopt</span>
|
||
<span class="k">try</span><span class="p">:</span>
|
||
<span class="n">opts</span><span class="p">,</span> <span class="n">args</span> <span class="o">=</span> <span class="n">getopt</span><span class="o">.</span><span class="n">getopt</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="s2">"qr:"</span><span class="p">)</span>
|
||
<span class="k">except</span> <span class="n">getopt</span><span class="o">.</span><span class="n">error</span> <span class="k">as</span> <span class="n">detail</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">detail</span><span class="p">))</span>
|
||
<span class="n">noisy</span> <span class="o">=</span> <span class="mi">1</span>
|
||
<span class="n">qseen</span> <span class="o">=</span> <span class="n">rseen</span> <span class="o">=</span> <span class="mi">0</span>
|
||
<span class="k">for</span> <span class="n">opt</span><span class="p">,</span> <span class="n">val</span> <span class="ow">in</span> <span class="n">opts</span><span class="p">:</span>
|
||
<span class="k">if</span> <span class="n">opt</span> <span class="o">==</span> <span class="s2">"-q"</span><span class="p">:</span>
|
||
<span class="n">qseen</span> <span class="o">=</span> <span class="mi">1</span>
|
||
<span class="n">noisy</span> <span class="o">=</span> <span class="mi">0</span>
|
||
<span class="k">elif</span> <span class="n">opt</span> <span class="o">==</span> <span class="s2">"-r"</span><span class="p">:</span>
|
||
<span class="n">rseen</span> <span class="o">=</span> <span class="mi">1</span>
|
||
<span class="n">whichfile</span> <span class="o">=</span> <span class="n">val</span>
|
||
<span class="k">if</span> <span class="n">qseen</span> <span class="ow">and</span> <span class="n">rseen</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="s2">"can't specify both -q and -r"</span><span class="p">)</span>
|
||
<span class="k">if</span> <span class="n">rseen</span><span class="p">:</span>
|
||
<span class="k">if</span> <span class="n">args</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="s2">"no args allowed with -r option"</span><span class="p">)</span>
|
||
<span class="k">if</span> <span class="n">whichfile</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="s2">"2"</span><span class="p">):</span>
|
||
<span class="n">restore</span><span class="p">(</span><span class="n">whichfile</span><span class="p">)</span>
|
||
<span class="k">return</span> <span class="mi">1</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="s2">"-r value must be 1 or 2"</span><span class="p">)</span>
|
||
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">fail</span><span class="p">(</span><span class="s2">"need 2 filename args"</span><span class="p">)</span>
|
||
<span class="n">f1name</span><span class="p">,</span> <span class="n">f2name</span> <span class="o">=</span> <span class="n">args</span>
|
||
<span class="k">if</span> <span class="n">noisy</span><span class="p">:</span>
|
||
<span class="nb">print</span><span class="p">(</span><span class="s1">'-:'</span><span class="p">,</span> <span class="n">f1name</span><span class="p">)</span>
|
||
<span class="nb">print</span><span class="p">(</span><span class="s1">'+:'</span><span class="p">,</span> <span class="n">f2name</span><span class="p">)</span>
|
||
<span class="k">return</span> <span class="n">fcompare</span><span class="p">(</span><span class="n">f1name</span><span class="p">,</span> <span class="n">f2name</span><span class="p">)</span>
|
||
|
||
<span class="c1"># read ndiff output from stdin, and print file1 (which=='1') or</span>
|
||
<span class="c1"># file2 (which=='2') to stdout</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">restore</span><span class="p">(</span><span class="n">which</span><span class="p">):</span>
|
||
<span class="n">restored</span> <span class="o">=</span> <span class="n">difflib</span><span class="o">.</span><span class="n">restore</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">stdin</span><span class="o">.</span><span class="n">readlines</span><span class="p">(),</span> <span class="n">which</span><span class="p">)</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">writelines</span><span class="p">(</span><span class="n">restored</span><span class="p">)</span>
|
||
|
||
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
|
||
<span class="n">main</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">:])</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
</section>
|
||
|
||
|
||
<div class="clearer"></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="Main">
|
||
<div class="sphinxsidebarwrapper">
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">difflib</span></code> — Helpers for computing deltas</a><ul>
|
||
<li><a class="reference internal" href="#sequencematcher-objects">SequenceMatcher Objects</a></li>
|
||
<li><a class="reference internal" href="#sequencematcher-examples">SequenceMatcher Examples</a></li>
|
||
<li><a class="reference internal" href="#differ-objects">Differ Objects</a></li>
|
||
<li><a class="reference internal" href="#differ-example">Differ Example</a></li>
|
||
<li><a class="reference internal" href="#a-command-line-interface-to-difflib">A command-line interface to difflib</a></li>
|
||
<li><a class="reference internal" href="#ndiff-example">ndiff example</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="re.html"
|
||
title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">re</span></code> — Regular expression operations</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="textwrap.html"
|
||
title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">textwrap</span></code> — Text wrapping and filling</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/library/difflib.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
<div id="sidebarbutton" title="Collapse sidebar">
|
||
<span>«</span>
|
||
</div>
|
||
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
>index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="textwrap.html" title="textwrap — Text wrapping and filling"
|
||
>next</a> |</li>
|
||
<li class="right" >
|
||
<a href="re.html" title="re — Regular expression operations"
|
||
>previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="text.html" >Text Processing Services</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">difflib</span></code> — Helpers for computing deltas</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
©
|
||
<a href="../copyright.html">
|
||
|
||
Copyright
|
||
|
||
</a>
|
||
2001-2025, Python Software Foundation.
|
||
<br />
|
||
This page is licensed under the Python Software Foundation License Version 2.
|
||
<br />
|
||
Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.
|
||
<br />
|
||
|
||
See <a href="/license.html">History and License</a> for more information.<br />
|
||
|
||
|
||
<br />
|
||
|
||
The Python Software Foundation is a non-profit corporation.
|
||
<a href="https://www.python.org/psf/donations/">Please donate.</a>
|
||
<br />
|
||
<br />
|
||
Last updated on Apr 08, 2025 (14:33 UTC).
|
||
|
||
<a href="/bugs.html">Found a bug</a>?
|
||
|
||
<br />
|
||
|
||
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |