<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Python on Zs&#39;s Blog</title>
    <link>https://blog.zzsqwq.cn/categories/python/</link>
    <description>Recent content in Python on Zs&#39;s Blog</description>
    <follow_challenge>
      <feedId>62734001391548416</feedId>
      <userId>62689941916008448</userId>
    </follow_challenge>
    <generator>Hugo</generator>
    <language>en</language>
    <lastBuildDate>Sun, 16 May 2021 15:19:00 +0000</lastBuildDate>
    <atom:link href="https://blog.zzsqwq.cn/categories/python/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>利用神经网络进行波士顿房价预测</title>
      <link>https://blog.zzsqwq.cn/posts/182/</link>
      <pubDate>Sun, 16 May 2021 15:19:00 +0000</pubDate>
      <guid>https://blog.zzsqwq.cn/posts/182/</guid>
      <description>&lt;h3 id=&#34;前言&#34;&gt;前言&lt;/h3&gt;
&lt;p&gt;前一阵学校有五一数模节校赛，和朋友一起参加做B题，波士顿房价预测，算是第一次自己动手实现一个简单的小网络吧，虽然很简单，但还是想记录一下。&lt;/p&gt;
&lt;h3 id=&#34;题目介绍&#34;&gt;题目介绍&lt;/h3&gt;
&lt;p&gt;波士顿住房数据由哈里森和鲁宾菲尔德于1978年Harrison and Rubinfeld&lt;sup&gt;&lt;a href=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/406125417.png&#34;&gt;1&lt;/a&gt;&lt;/sup&gt;收集。它包括了波士顿大区每个调查行政区的506个观察值。1980年Belsley et al.&lt;sup&gt;&lt;a href=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/3238192089.png&#34;&gt;2&lt;/a&gt;&lt;/sup&gt;曾对此数据做过分析。&lt;/p&gt;
&lt;p&gt;数据一共14列，每一列的含义分别如下：&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;英文简称&lt;/th&gt;
					&lt;th&gt;详细含义&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;CRIM&lt;/td&gt;
					&lt;td&gt;城镇的人均犯罪率&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;ZN&lt;/td&gt;
					&lt;td&gt;大于25,000平方英尺的地块的住宅用地比例。&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;INDUS&lt;/td&gt;
					&lt;td&gt;每个镇的非零售业务英亩的比例。&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;CHAS&lt;/td&gt;
					&lt;td&gt;查尔斯河虚拟变量（如果环河，则等于1；否则等于0）&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;NOX&lt;/td&gt;
					&lt;td&gt;一氧化氮的浓度（百万分之几）&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;RM&lt;/td&gt;
					&lt;td&gt;每个住宅的平均房间数&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;AGE&lt;/td&gt;
					&lt;td&gt;1940年之前建造的自有住房的比例&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;DIS&lt;/td&gt;
					&lt;td&gt;到五个波士顿就业中心的加权距离&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;RAD&lt;/td&gt;
					&lt;td&gt;径向公路通达性的指标&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;TAX&lt;/td&gt;
					&lt;td&gt;每一万美元的全值财产税率&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;PTRATIO&lt;/td&gt;
					&lt;td&gt;各镇的师生比率&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;B&lt;/td&gt;
					&lt;td&gt;计算方法为 $1000(B_k-0.63)^2$，其中Bk是按城镇划分的非裔美国人的比例&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;LSTAT&lt;/td&gt;
					&lt;td&gt;底层人口的百分比(%)&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;&lt;strong&gt;price&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;自有住房数的中位数，单位（千美元）&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;基于上述数据，请完成以下问题：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;建立波士顿房价预测模型并对预测结果进行评价。&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;问题分析&#34;&gt;问题分析&lt;/h3&gt;
&lt;p&gt;首先这道题目的很明确，数据一共是 $506×14$ 的一个矩阵，有十三维的自变量，通过建立一个模型来拟合回归出最终的因变量 price，即户主拥有住房价值的中位数。这是一个回归问题，综合考虑有以下两个思路&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;通过各种回归算法（GradientBoostingRegressor，RandomForestRegressor，ExtraTreesRegressor，LinearRegressor等）结合全部或部分自变量来回归最终的price&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;建立前馈神经网络模型，根据通用逼近定理，我们可以拟合此回归模型。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;我们对上述模型来进行实现并确定评估标准来对他们进行比较，选择最优的模型作为预测模型。&lt;/p&gt;
&lt;h3 id=&#34;算法流程&#34;&gt;算法流程&lt;/h3&gt;
&lt;h4 id=&#34;传统的回归算法&#34;&gt;传统的回归算法&lt;/h4&gt;
&lt;h5 id=&#34;自变量的选择&#34;&gt;自变量的选择&lt;/h5&gt;
&lt;p&gt;首先，考虑到数据集中13列自变量其中某一些可能和最终的房价并无强相关性，如果全部使用进行预测可能会对模型引入噪声，因此我们首先计算了房价price与各个自变量之间的相关系数 $r$ ，其中 $r$ 计算公式如下：
$$
r = \frac{\sum(x_i-\bar{x})(y_i-\bar{y})}{\sqrt{\sum(x_i-\bar{x})^2\sum(y_i-\bar{y})^2}}
$$
其中 $x_i,y_i$ 为数据的每个分量，$\bar{x}，\bar{y}$ 为数据的均值&lt;/p&gt;
&lt;p&gt;该系数反映了两变量之间的相关性，$r$ 的绝对值介于 $[0,1]$ 区间内，$|r|$ 越接近1，表示两数据相关性越高，反之越低。计算后结果如下：&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;CRIM&lt;/th&gt;
					&lt;th&gt;ZN&lt;/th&gt;
					&lt;th&gt;INDUS&lt;/th&gt;
					&lt;th&gt;CHAS&lt;/th&gt;
					&lt;th&gt;NOX&lt;/th&gt;
					&lt;th&gt;RM&lt;/th&gt;
					&lt;th&gt;LSTAT&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;-0.385832&lt;/td&gt;
					&lt;td&gt;0.360445&lt;/td&gt;
					&lt;td&gt;-0.483725&lt;/td&gt;
					&lt;td&gt;0.175260&lt;/td&gt;
					&lt;td&gt;-0.427321&lt;/td&gt;
					&lt;td&gt;0.695360&lt;/td&gt;
					&lt;td&gt;-0.737663&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;&lt;strong&gt;AGE&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;strong&gt;DIS&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;strong&gt;RAD&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;strong&gt;TAX&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;strong&gt;PTRATIO&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;strong&gt;B&lt;/strong&gt;&lt;/td&gt;
					&lt;td&gt;&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;-0.376955&lt;/td&gt;
					&lt;td&gt;0.249929&lt;/td&gt;
					&lt;td&gt;-0.381626&lt;/td&gt;
					&lt;td&gt;-0.468536&lt;/td&gt;
					&lt;td&gt;-0.507787&lt;/td&gt;
					&lt;td&gt;0.333461&lt;/td&gt;
					&lt;td&gt;&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;观察结果可以发现，在给定的十三个变量中，&lt;strong&gt;LSTAT &lt;strong&gt;与 &lt;strong&gt;price&lt;/strong&gt; 的相关程度最高$(|r|&amp;gt;0.7)$，其次是 &lt;strong&gt;RM&lt;/strong&gt; 与&lt;/strong&gt;PTRATIO&lt;/strong&gt; $(|r|&amp;gt;0.5)$，再者是 &lt;strong&gt;TAX,INDUS,NOX&lt;/strong&gt; $(|r|&amp;gt;0.4)$，除上述之外的七个变量都与 &lt;strong&gt;price&lt;/strong&gt; 无较强的相关性，因此我们考虑使用六个相关性较强变量和十三个变量分别来对房价进行预测，并对他们进行对比，来寻找最优的回归模型。&lt;/p&gt;
&lt;h5 id=&#34;模型的构建&#34;&gt;模型的构建&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;首先我们使用了sklearn中自带的 boston 数据集，并将整体数据集随机划分为了训练集和测试集两部分，所占比例分别为80%和20%。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;然后，我们利用Linear,Ridge,Lasso,ElasticNet,DecisionTree,GradientBoosting,RandomForest,ExtraTrees八种模型通过训练集对其进行训练。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;接下来，我们利用训练集拟合得到的模型，使用测试集对其进行测试，与 Ground Truth 进行对比，并通过 $R^2$ 来评价该预测结果，其中 $R^2$ 计算公式如下，其是衡量回归模型好坏的常见指标，其值一般处于[0,1]之间，$R^2$ 越接近1，说明模型的性能越好。
$$
R^2 = 1-\frac{\sum(\hat{y_i}-y_i)^2}{\sum(\bar{y}-y_i)^2}
$$&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;最后，考虑到模型的训练及预测可能具有偶然性，因此我们对于每一个模型进行20次训练及预测，利用20次的结果对其进行综合评价。利用得到的结果绘制 &lt;strong&gt;箱线图&lt;/strong&gt; 所得结果如下：&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img alt=&#34;使用六变量和十三个变量进行拟合的对比&#34; loading=&#34;lazy&#34; src=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/406125417.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;分析最终结果可以发现，无论是使用六个相关性较强变量还是十三个变量来进行预测，GradientBoost（梯度提升决策树）回归模型都是最好的，此外，我们可以发现，利用十三个变量要比利用六个主要变量来进行预测比有着更好的效果。&lt;/p&gt;
&lt;h4 id=&#34;前馈神经网络&#34;&gt;前馈神经网络&lt;/h4&gt;
&lt;h5 id=&#34;模型的构建-1&#34;&gt;模型的构建&lt;/h5&gt;
&lt;p&gt;近年来，神经网络理论不断发展，前馈神经网络（多层感知机、全连接神经网络）越来越多的被利用到数据分析中，因此考虑使用前馈神经网络来解决此问题。&lt;/p&gt;
&lt;p&gt;前馈神经网络（全连接神经网络）的网络结构一般由三部分构成，输入层，隐藏层，以及输出层，输入层与输出层一般只有一层，隐藏层可有多层。中间利用非线性函数作为激活函数可以使得网络具有拟合非线性函数的能力&lt;/p&gt;
&lt;p&gt;根据通用近似定理:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;通用近似定理&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;对于具有线性输出层和至少一个使用“挤压”性质的激活函数的隐藏层组成的前馈神经网络，只要其隐藏层神经元的数量足够，它可以以任意精度来近似任何从一个定义在实数空间中的有界闭集函数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;只要隐藏层网络维度够高，就可以拟合任意的函数。&lt;/p&gt;
&lt;p&gt;考虑到我们的模型有六维or十三维的数据输入，因此我们建立两层前馈神经网络，中间具有一层隐藏层，维度为1000维，激活函数使用Relu，Relu函数有以下优点:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Relu相比于传统的Sigmoid、Tanh，导数更加好求，反向传播就是不断的更新参数的过程，因为其导数不复杂形式简单，可以使得网络训练更快速。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;此外，当数值过大或者过小，Sigmoid，Tanh的导数接近于0，Relu为非饱和激活函数则不存在这种现象，可以很好的解决梯度消失的问题&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Relu函数及网络结构图如图所示：&lt;/p&gt;
&lt;p&gt;$$
Relu:f(x) = max(0,x)
$$&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;构建的前馈神经网络结构图&#34; loading=&#34;lazy&#34; src=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/3238192089.png&#34;&gt;&lt;/p&gt;
&lt;h5 id=&#34;具体实现&#34;&gt;具体实现&lt;/h5&gt;
&lt;p&gt;利用流行的深度学习框架 &lt;strong&gt;Pytorch&lt;/strong&gt; 来对模型进行实现。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;首先，将数据集随机划分为训练集和测试集两部分，分别占80%和20%，并将其转化为Pytorch中的张量形式。&lt;/li&gt;
&lt;li&gt;然后，利用MinMaxScaler对输入数据进行归一化，利用下列公式将其统一归一化为 $[0,1]$ 之间，以求模型能够更快的收敛。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
MinMaxScaler:x^{*} = \frac{x-min(x)}{max(x)-min(x)}
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接下来，构建网络模型，利用 mseloss 作为损失函数，在训练过程中利用反向传播使其最终收敛为0。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
MseLoss = \frac{1}{2n}\sum||y(x)-a^L(x)||^2
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;最后，我们设置网络的学习率为0.01，训练10000个epoch，发现其loss最终降低到0.3%左右，我们利用上文提到的 $R^2$ 对结果进行评估并与回归模型进行对比，通过观察图片可以发现，前馈神经网络相比于传统的回归模型有着更好的拟合效果， 20次预测得到的$R^2$平均值达到了0.95，此外中位数，最大值，最小值也要比回归模型更加优秀，因此我们采用前馈神经网络模型来对最后的房价进行预测。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img alt=&#34;添加前馈神经网络后与其他模型进行比较&#34; loading=&#34;lazy&#34; src=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/2897732866.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;训练过程中的loss曲线&#34; loading=&#34;lazy&#34; src=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/3640570809.jpg&#34;&gt;&lt;/p&gt;
&lt;h3 id=&#34;最终预测&#34;&gt;最终预测&lt;/h3&gt;
&lt;p&gt;最终我们利用构建的前馈神经网络模型进行预测，利用测试集对其进行对比，绘制预测如下：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;predict_groundtruth.png&#34; loading=&#34;lazy&#34; src=&#34;https://blog.zzsqwq.cn/usr/uploads/2021/05/1130005314.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;​&lt;/p&gt;
&lt;p&gt;可以看到其中很多点都覆盖的很好，即预测准确。&lt;/p&gt;
&lt;p&gt;通过理论对模型进行量化分析，计算预测的 $R^2$
$$
R^2 = 1-\frac{\sum(\hat{y_i}-y_i)^2}{\sum(\bar{y}-y_i)^2} = 1-0.01357 = 0.98643=98.643%
$$
可以发现 $R^2$ 十分接近1，说明回归模型性能良好，符合要求。&lt;/p&gt;
&lt;h3 id=&#34;实现代码&#34;&gt;实现代码&lt;/h3&gt;
&lt;p&gt;代码放在我的Github了，其中写了较详细的README，链接为 &lt;a href=&#34;https://github.com/zzsqwq/BostonPredict&#34;&gt;BostonPredict &lt;/a&gt;&lt;/p&gt;
&lt;h3 id=&#34;参考链接&#34;&gt;参考链接&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://zhuanlan.zhihu.com/p/89873990&#34;&gt;很系统的波士顿房价预测研究报告（期中作业）&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://www.cnblogs.com/gwj23/p/10604611.html&#34;&gt;作业-机器学习-波士顿房价预测 四种回归算法&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://zhuanlan.zhihu.com/p/48702850&#34;&gt;基于Python预测波士顿房价&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://cloud.tencent.com/developer/article/1574255&#34;&gt;波士顿房价预测——回归分析案例（献给初学者）&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</description>
      <content:encoded><![CDATA[<h3 id="前言">前言</h3>
<p>前一阵学校有五一数模节校赛，和朋友一起参加做B题，波士顿房价预测，算是第一次自己动手实现一个简单的小网络吧，虽然很简单，但还是想记录一下。</p>
<h3 id="题目介绍">题目介绍</h3>
<p>波士顿住房数据由哈里森和鲁宾菲尔德于1978年Harrison and Rubinfeld<sup><a href="https://blog.zzsqwq.cn/usr/uploads/2021/05/406125417.png">1</a></sup>收集。它包括了波士顿大区每个调查行政区的506个观察值。1980年Belsley et al.<sup><a href="https://blog.zzsqwq.cn/usr/uploads/2021/05/3238192089.png">2</a></sup>曾对此数据做过分析。</p>
<p>数据一共14列，每一列的含义分别如下：</p>
<table>
	<thead>
			<tr>
					<th>英文简称</th>
					<th>详细含义</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CRIM</td>
					<td>城镇的人均犯罪率</td>
			</tr>
			<tr>
					<td>ZN</td>
					<td>大于25,000平方英尺的地块的住宅用地比例。</td>
			</tr>
			<tr>
					<td>INDUS</td>
					<td>每个镇的非零售业务英亩的比例。</td>
			</tr>
			<tr>
					<td>CHAS</td>
					<td>查尔斯河虚拟变量（如果环河，则等于1；否则等于0）</td>
			</tr>
			<tr>
					<td>NOX</td>
					<td>一氧化氮的浓度（百万分之几）</td>
			</tr>
			<tr>
					<td>RM</td>
					<td>每个住宅的平均房间数</td>
			</tr>
			<tr>
					<td>AGE</td>
					<td>1940年之前建造的自有住房的比例</td>
			</tr>
			<tr>
					<td>DIS</td>
					<td>到五个波士顿就业中心的加权距离</td>
			</tr>
			<tr>
					<td>RAD</td>
					<td>径向公路通达性的指标</td>
			</tr>
			<tr>
					<td>TAX</td>
					<td>每一万美元的全值财产税率</td>
			</tr>
			<tr>
					<td>PTRATIO</td>
					<td>各镇的师生比率</td>
			</tr>
			<tr>
					<td>B</td>
					<td>计算方法为 $1000(B_k-0.63)^2$，其中Bk是按城镇划分的非裔美国人的比例</td>
			</tr>
			<tr>
					<td>LSTAT</td>
					<td>底层人口的百分比(%)</td>
			</tr>
			<tr>
					<td><strong>price</strong></td>
					<td>自有住房数的中位数，单位（千美元）</td>
			</tr>
	</tbody>
</table>
<p>基于上述数据，请完成以下问题：</p>
<p><strong>建立波士顿房价预测模型并对预测结果进行评价。</strong></p>
<h3 id="问题分析">问题分析</h3>
<p>首先这道题目的很明确，数据一共是 $506×14$ 的一个矩阵，有十三维的自变量，通过建立一个模型来拟合回归出最终的因变量 price，即户主拥有住房价值的中位数。这是一个回归问题，综合考虑有以下两个思路</p>
<ol>
<li>
<p>通过各种回归算法（GradientBoostingRegressor，RandomForestRegressor，ExtraTreesRegressor，LinearRegressor等）结合全部或部分自变量来回归最终的price</p>
</li>
<li>
<p>建立前馈神经网络模型，根据通用逼近定理，我们可以拟合此回归模型。</p>
</li>
</ol>
<p>我们对上述模型来进行实现并确定评估标准来对他们进行比较，选择最优的模型作为预测模型。</p>
<h3 id="算法流程">算法流程</h3>
<h4 id="传统的回归算法">传统的回归算法</h4>
<h5 id="自变量的选择">自变量的选择</h5>
<p>首先，考虑到数据集中13列自变量其中某一些可能和最终的房价并无强相关性，如果全部使用进行预测可能会对模型引入噪声，因此我们首先计算了房价price与各个自变量之间的相关系数 $r$ ，其中 $r$ 计算公式如下：
$$
r = \frac{\sum(x_i-\bar{x})(y_i-\bar{y})}{\sqrt{\sum(x_i-\bar{x})^2\sum(y_i-\bar{y})^2}}
$$
其中 $x_i,y_i$ 为数据的每个分量，$\bar{x}，\bar{y}$ 为数据的均值</p>
<p>该系数反映了两变量之间的相关性，$r$ 的绝对值介于 $[0,1]$ 区间内，$|r|$ 越接近1，表示两数据相关性越高，反之越低。计算后结果如下：</p>
<table>
	<thead>
			<tr>
					<th>CRIM</th>
					<th>ZN</th>
					<th>INDUS</th>
					<th>CHAS</th>
					<th>NOX</th>
					<th>RM</th>
					<th>LSTAT</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>-0.385832</td>
					<td>0.360445</td>
					<td>-0.483725</td>
					<td>0.175260</td>
					<td>-0.427321</td>
					<td>0.695360</td>
					<td>-0.737663</td>
			</tr>
			<tr>
					<td><strong>AGE</strong></td>
					<td><strong>DIS</strong></td>
					<td><strong>RAD</strong></td>
					<td><strong>TAX</strong></td>
					<td><strong>PTRATIO</strong></td>
					<td><strong>B</strong></td>
					<td></td>
			</tr>
			<tr>
					<td>-0.376955</td>
					<td>0.249929</td>
					<td>-0.381626</td>
					<td>-0.468536</td>
					<td>-0.507787</td>
					<td>0.333461</td>
					<td></td>
			</tr>
	</tbody>
</table>
<p>观察结果可以发现，在给定的十三个变量中，<strong>LSTAT <strong>与 <strong>price</strong> 的相关程度最高$(|r|&gt;0.7)$，其次是 <strong>RM</strong> 与</strong>PTRATIO</strong> $(|r|&gt;0.5)$，再者是 <strong>TAX,INDUS,NOX</strong> $(|r|&gt;0.4)$，除上述之外的七个变量都与 <strong>price</strong> 无较强的相关性，因此我们考虑使用六个相关性较强变量和十三个变量分别来对房价进行预测，并对他们进行对比，来寻找最优的回归模型。</p>
<h5 id="模型的构建">模型的构建</h5>
<ul>
<li>
<p>首先我们使用了sklearn中自带的 boston 数据集，并将整体数据集随机划分为了训练集和测试集两部分，所占比例分别为80%和20%。</p>
</li>
<li>
<p>然后，我们利用Linear,Ridge,Lasso,ElasticNet,DecisionTree,GradientBoosting,RandomForest,ExtraTrees八种模型通过训练集对其进行训练。</p>
</li>
<li>
<p>接下来，我们利用训练集拟合得到的模型，使用测试集对其进行测试，与 Ground Truth 进行对比，并通过 $R^2$ 来评价该预测结果，其中 $R^2$ 计算公式如下，其是衡量回归模型好坏的常见指标，其值一般处于[0,1]之间，$R^2$ 越接近1，说明模型的性能越好。
$$
R^2 = 1-\frac{\sum(\hat{y_i}-y_i)^2}{\sum(\bar{y}-y_i)^2}
$$</p>
</li>
<li>
<p>最后，考虑到模型的训练及预测可能具有偶然性，因此我们对于每一个模型进行20次训练及预测，利用20次的结果对其进行综合评价。利用得到的结果绘制 <strong>箱线图</strong> 所得结果如下：</p>
</li>
</ul>
<p><img alt="使用六变量和十三个变量进行拟合的对比" loading="lazy" src="https://blog.zzsqwq.cn/usr/uploads/2021/05/406125417.png"></p>
<p>分析最终结果可以发现，无论是使用六个相关性较强变量还是十三个变量来进行预测，GradientBoost（梯度提升决策树）回归模型都是最好的，此外，我们可以发现，利用十三个变量要比利用六个主要变量来进行预测比有着更好的效果。</p>
<h4 id="前馈神经网络">前馈神经网络</h4>
<h5 id="模型的构建-1">模型的构建</h5>
<p>近年来，神经网络理论不断发展，前馈神经网络（多层感知机、全连接神经网络）越来越多的被利用到数据分析中，因此考虑使用前馈神经网络来解决此问题。</p>
<p>前馈神经网络（全连接神经网络）的网络结构一般由三部分构成，输入层，隐藏层，以及输出层，输入层与输出层一般只有一层，隐藏层可有多层。中间利用非线性函数作为激活函数可以使得网络具有拟合非线性函数的能力</p>
<p>根据通用近似定理:</p>
<blockquote>
<p><strong>通用近似定理</strong></p>
<p>对于具有线性输出层和至少一个使用“挤压”性质的激活函数的隐藏层组成的前馈神经网络，只要其隐藏层神经元的数量足够，它可以以任意精度来近似任何从一个定义在实数空间中的有界闭集函数。</p>
</blockquote>
<p>只要隐藏层网络维度够高，就可以拟合任意的函数。</p>
<p>考虑到我们的模型有六维or十三维的数据输入，因此我们建立两层前馈神经网络，中间具有一层隐藏层，维度为1000维，激活函数使用Relu，Relu函数有以下优点:</p>
<ul>
<li>
<p>Relu相比于传统的Sigmoid、Tanh，导数更加好求，反向传播就是不断的更新参数的过程，因为其导数不复杂形式简单，可以使得网络训练更快速。</p>
</li>
<li>
<p>此外，当数值过大或者过小，Sigmoid，Tanh的导数接近于0，Relu为非饱和激活函数则不存在这种现象，可以很好的解决梯度消失的问题</p>
</li>
</ul>
<p>Relu函数及网络结构图如图所示：</p>
<p>$$
Relu:f(x) = max(0,x)
$$</p>
<p><img alt="构建的前馈神经网络结构图" loading="lazy" src="https://blog.zzsqwq.cn/usr/uploads/2021/05/3238192089.png"></p>
<h5 id="具体实现">具体实现</h5>
<p>利用流行的深度学习框架 <strong>Pytorch</strong> 来对模型进行实现。</p>
<ul>
<li>首先，将数据集随机划分为训练集和测试集两部分，分别占80%和20%，并将其转化为Pytorch中的张量形式。</li>
<li>然后，利用MinMaxScaler对输入数据进行归一化，利用下列公式将其统一归一化为 $[0,1]$ 之间，以求模型能够更快的收敛。</li>
</ul>
<p>$$
MinMaxScaler:x^{*} = \frac{x-min(x)}{max(x)-min(x)}
$$</p>
<ul>
<li>接下来，构建网络模型，利用 mseloss 作为损失函数，在训练过程中利用反向传播使其最终收敛为0。</li>
</ul>
<p>$$
MseLoss = \frac{1}{2n}\sum||y(x)-a^L(x)||^2
$$</p>
<ul>
<li>最后，我们设置网络的学习率为0.01，训练10000个epoch，发现其loss最终降低到0.3%左右，我们利用上文提到的 $R^2$ 对结果进行评估并与回归模型进行对比，通过观察图片可以发现，前馈神经网络相比于传统的回归模型有着更好的拟合效果， 20次预测得到的$R^2$平均值达到了0.95，此外中位数，最大值，最小值也要比回归模型更加优秀，因此我们采用前馈神经网络模型来对最后的房价进行预测。</li>
</ul>
<p><img alt="添加前馈神经网络后与其他模型进行比较" loading="lazy" src="https://blog.zzsqwq.cn/usr/uploads/2021/05/2897732866.png"></p>
<p><img alt="训练过程中的loss曲线" loading="lazy" src="https://blog.zzsqwq.cn/usr/uploads/2021/05/3640570809.jpg"></p>
<h3 id="最终预测">最终预测</h3>
<p>最终我们利用构建的前馈神经网络模型进行预测，利用测试集对其进行对比，绘制预测如下：</p>
<p><img alt="predict_groundtruth.png" loading="lazy" src="https://blog.zzsqwq.cn/usr/uploads/2021/05/1130005314.png"></p>
<p>​</p>
<p>可以看到其中很多点都覆盖的很好，即预测准确。</p>
<p>通过理论对模型进行量化分析，计算预测的 $R^2$
$$
R^2 = 1-\frac{\sum(\hat{y_i}-y_i)^2}{\sum(\bar{y}-y_i)^2} = 1-0.01357 = 0.98643=98.643%
$$
可以发现 $R^2$ 十分接近1，说明回归模型性能良好，符合要求。</p>
<h3 id="实现代码">实现代码</h3>
<p>代码放在我的Github了，其中写了较详细的README，链接为 <a href="https://github.com/zzsqwq/BostonPredict">BostonPredict </a></p>
<h3 id="参考链接">参考链接</h3>
<ul>
<li>
<p><a href="https://zhuanlan.zhihu.com/p/89873990">很系统的波士顿房价预测研究报告（期中作业）</a></p>
</li>
<li>
<p><a href="https://www.cnblogs.com/gwj23/p/10604611.html">作业-机器学习-波士顿房价预测 四种回归算法</a></p>
</li>
<li>
<p><a href="https://zhuanlan.zhihu.com/p/48702850">基于Python预测波士顿房价</a></p>
</li>
<li>
<p><a href="https://cloud.tencent.com/developer/article/1574255">波士顿房价预测——回归分析案例（献给初学者）</a></p>
</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>Python初步学习</title>
      <link>https://blog.zzsqwq.cn/posts/66/</link>
      <pubDate>Sat, 18 Apr 2020 01:24:00 +0000</pubDate>
      <guid>https://blog.zzsqwq.cn/posts/66/</guid>
      <description>&lt;h1 id=&#34;python学习笔记&#34;&gt;Python学习笔记&lt;/h1&gt;
&lt;h2 id=&#34;python的不同解释器&#34;&gt;Python的不同解释器&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;CPython&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这是自带的用C语言开发的解释器，因此叫CPython。它也是使用最广的Python解释器。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;IPython&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这是基于CPython之上的一个交互式解释器，只是相比于CPython多了交互上的优化。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;PyPy&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;它的目标是执行速度。PyPy采用&lt;a href=&#34;http://en.wikipedia.org/wiki/Just-in-time_compilation&#34;&gt;JIT技术&lt;/a&gt;，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。他与CPython略有不同。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Jython&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;IronPython&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;python基础&#34;&gt;Python基础&lt;/h2&gt;
&lt;h3 id=&#34;简单的输入和输出io&#34;&gt;简单的输入和输出(I/O)&lt;/h3&gt;
&lt;h4 id=&#34;输入&#34;&gt;输入&lt;/h4&gt;
&lt;p&gt;python提供了一个 &lt;code&gt;input()&lt;/code&gt; 函数供我们输入使用，这读入的是字符串数据，并返回，可以将返回值存放在一个变量中。&lt;strong&gt;input&lt;/strong&gt;函数中可以带字符串，这段字符串在输入前会打印在屏幕上，这使得我们具有很好的交互性，好比我们写:&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;name&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;input&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;hello,friend! please input your name&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;The input name is &amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;name&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么这时候我们运行上述程序，就会提示 &lt;code&gt;hello , friend! please input your name&lt;/code&gt; ，这就提示我们应该输入名字。&lt;/p&gt;
&lt;p&gt;这里需要注意的是，&lt;code&gt;input()&lt;/code&gt; 函数读入的是一个字符串 &lt;code&gt;str&lt;/code&gt; ，就算我们输入了整数他也是一个字符串，如果我们要用真正的整数，那么就需要用 &lt;code&gt;int()&lt;/code&gt; 进行类型强制转换。如果其中不是合法的整数，那么会报错。&lt;/p&gt;
&lt;h4 id=&#34;输出&#34;&gt;输出&lt;/h4&gt;
&lt;p&gt;python中的输出函数是 &lt;code&gt;print()&lt;/code&gt; ，这和 &lt;strong&gt;C++&lt;/strong&gt; 的&lt;code&gt;printf&lt;/code&gt; 差了一个f。我们在函数的参数中传入什么，他就会打印什么。好比我们写  &lt;code&gt;print(&amp;quot;heelo,world&amp;quot;) &lt;/code&gt; ，那么运行就会打印 &lt;code&gt;hello,world&lt;/code&gt;  在屏幕上。&lt;code&gt;print&lt;/code&gt; 支持我们传入多个参数，好比 &lt;code&gt;printf(&amp;quot;my name is&amp;quot;,&amp;quot;zs&amp;quot;)&lt;/code&gt; ，两两之间用逗号隔开，这在输出时会被解析成空格，也就是说两段字符串之间有一个空格。当然此函数也可以打印整数等。&lt;/p&gt;
&lt;h3 id=&#34;一些规则&#34;&gt;一些规则&lt;/h3&gt;
&lt;h4 id=&#34;缩进&#34;&gt;缩进&lt;/h4&gt;
&lt;p&gt;Python中对代码块的区分，不是用C++的大括号，而是用缩进。处于连续同一缩进的是一个代码块，这也是为什么Python又被戏称为&lt;strong&gt;游标卡尺语言&lt;/strong&gt;的原因。&lt;strong&gt;当语句以冒号&lt;code&gt;:&lt;/code&gt;结尾时，缩进的语句视为代码块。&lt;strong&gt;我们通常用&lt;/strong&gt;一个Tab / 四个空格&lt;/strong&gt; 的缩进。&lt;/p&gt;
&lt;h4 id=&#34;注释&#34;&gt;注释&lt;/h4&gt;
&lt;p&gt;Python的注释用的是 &lt;code&gt;#&lt;/code&gt; ，而 C++ 中的注释用的是 &lt;code&gt;\\&lt;/code&gt; 。&lt;/p&gt;
&lt;h4 id=&#34;case-sensitive&#34;&gt;Case Sensitive&lt;/h4&gt;
&lt;p&gt;Python中是大小写敏感的，也就是 a 和 A 不是同一个东西。&lt;/p&gt;
&lt;h3 id=&#34;数据类型&#34;&gt;数据类型&lt;/h3&gt;
&lt;h4 id=&#34;1-整数&#34;&gt;1. 整数&lt;/h4&gt;
&lt;p&gt;Python一个很大的好处就是可以处理任意大小的整数，包括负整数。这也是为什么很多大数题大家都喜欢用Python，hhhh。多数地方都用十进制，但是也是支持其他进制的哈~好比 &lt;code&gt;0x&lt;/code&gt; 前缀就是16进制。&lt;/p&gt;
&lt;h4 id=&#34;2-浮点数&#34;&gt;2. 浮点数&lt;/h4&gt;
&lt;p&gt;浮点数是小数，之所以称为浮点数，是因为小数点位置在科学计数法中是可变的。这里需要注意，整数和浮点数在计算机内部存储方式不同，浮点数应该都是 &lt;code&gt;IEEE754&lt;/code&gt; 标准吧？整数之间的运算永远都是精确的，包括除法。而浮点数的运算则会有一定的误差。Python的浮点数也没有大小限制，但是超出一定范围就直接表示为&lt;code&gt;inf&lt;/code&gt;（无限大）。&lt;/p&gt;
&lt;h4 id=&#34;3-字符串&#34;&gt;3. 字符串&lt;/h4&gt;
&lt;p&gt;字符串是以单引号 &lt;code&gt;&#39;&#39;&lt;/code&gt; 或者双引号 &lt;code&gt;&amp;quot;&amp;quot;&lt;/code&gt; 括起来的任意文本。我们注意到&lt;strong&gt;Python&lt;/strong&gt;中&lt;strong&gt;没有单个字符的概念&lt;/strong&gt;，就算是单个字符也是一个字符串。如果&lt;code&gt;&#39;&#39;&lt;/code&gt; 括起来的字符串内部出现 &lt;code&gt;&#39;&#39;&lt;/code&gt; 需要使用&lt;code&gt;\&lt;/code&gt;转义，相同的，如果 &lt;code&gt;&amp;quot;&amp;quot;&lt;/code&gt; 括起来的字符串内部出现 &lt;code&gt;&amp;quot;&amp;quot;&lt;/code&gt; 需要转义。好比下面的程序&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;My name is &amp;#39;zs&amp;#39;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#合法  My name is &amp;#39;zs&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;My name is &amp;#34;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;zs&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#不合法 invalid syntax&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;My name is &lt;/span&gt;&lt;span class=&#34;se&#34;&gt;\&amp;#34;&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;zs&lt;/span&gt;&lt;span class=&#34;se&#34;&gt;\&amp;#34;&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;#合法 My name is &amp;#34;zs&amp;#34; &lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;My name is &amp;#34;zs&amp;#34;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#合法  My name is &amp;#34;zs&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;My name is &amp;#39;&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;zs&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#不合法 invalid syntax&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;My name is &lt;/span&gt;&lt;span class=&#34;se&#34;&gt;\&amp;#39;&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;zs&lt;/span&gt;&lt;span class=&#34;se&#34;&gt;\&amp;#39;&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;#合法 My name is &amp;#39;zs&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Python中也有很多转义字符，跟C++的很类似。&lt;code&gt;\n&lt;/code&gt;,&lt;code&gt;\t&lt;/code&gt;,&lt;code&gt;\\&lt;/code&gt;  分别代表换行，横向制表，字符&lt;code&gt;\&lt;/code&gt;  。在python中还支持用 &lt;code&gt;r&#39; &#39;&lt;/code&gt; 表示 &lt;code&gt;&#39;&#39;&lt;/code&gt;  内部的字符默认不转义。&lt;/p&gt;
&lt;p&gt;Python在输出多行语句时，可以用 &lt;code&gt;print(&#39;&#39;&#39;content&#39;&#39;&#39;)&lt;/code&gt; 其中content中的内容，支持用直觉上的换行。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&amp;#39;python
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;s1&#34;&gt;name
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;s1&#34;&gt;zs&amp;#39;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;# The output&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;python&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;name&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;zs&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;4-布尔值&#34;&gt;4. 布尔值&lt;/h4&gt;
&lt;p&gt;含有 &lt;strong&gt;Ture&lt;/strong&gt; 和 &lt;strong&gt;False&lt;/strong&gt; 两种类型，代表真和假。支持 &lt;code&gt;and&lt;/code&gt; ,  &lt;code&gt;or&lt;/code&gt; ,&lt;code&gt;not&lt;/code&gt; 三种运算。&lt;/p&gt;
&lt;h4 id=&#34;5-空值&#34;&gt;5. 空值&lt;/h4&gt;
&lt;p&gt;空值是Python中的一个特殊值，用 &lt;code&gt;None&lt;/code&gt; 表示。 &lt;code&gt;None&lt;/code&gt;不能理解为&lt;code&gt;0&lt;/code&gt;，因为&lt;code&gt;0&lt;/code&gt;是有意义的，而&lt;code&gt;None&lt;/code&gt;是一个特殊的空值。&lt;/p&gt;
&lt;h3 id=&#34;变量&#34;&gt;变量&lt;/h3&gt;
&lt;p&gt;变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和&lt;code&gt;_&lt;/code&gt;的组合，且不能用数字开头。&lt;/p&gt;
&lt;p&gt;变量命名时最好能做到顾名思义，当然也有很多规范的命名规则，可以自行百度。&lt;/p&gt;
&lt;p&gt;在 &lt;strong&gt;Python&lt;/strong&gt; 中我们不需要指定一个变量是特定的类型，它可以在不同的类型之间变来变去，这确实很方便，不过感觉也是很占内存和时间的。&lt;/p&gt;
&lt;p&gt;这种变量本身类型不固定的语言称之为&lt;strong&gt;动态语言&lt;/strong&gt;，与之对应的是&lt;strong&gt;静态语言&lt;/strong&gt;。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错&lt;/p&gt;
&lt;h3 id=&#34;常量&#34;&gt;常量&lt;/h3&gt;
&lt;p&gt;Python中没有C++中的const来限制常量，但是通常用&lt;strong&gt;变量名全大写来代表这个变量为一个常量&lt;/strong&gt;，但是这玩意是个约定俗成的，并不是说你这么写他就真是个常量了。&lt;/p&gt;
&lt;h3 id=&#34;字符串和编码&#34;&gt;字符串和编码&lt;/h3&gt;
&lt;h4 id=&#34;字符编码&#34;&gt;字符编码&lt;/h4&gt;
&lt;p&gt;字符编码有很多种，不同的语言也对应着不同的字符编码。常见的几个是 &lt;code&gt;ASCII&lt;/code&gt; ,&lt;code&gt;Unicode&lt;/code&gt; ,&lt;code&gt;UTF-8&lt;/code&gt;,&lt;code&gt;GB2313&lt;/code&gt; 他们分别是英文和特殊字符的编码，统一的一套编码，可变长的统一编码，常用的中文编码。&lt;/p&gt;
&lt;h4 id=&#34;python的字符串存储&#34;&gt;Python的字符串存储&lt;/h4&gt;
&lt;p&gt;Python 3的的字符串是 &lt;code&gt;Unicode&lt;/code&gt; 编码的，也就是说Python的字符串支持多语言，因为这是一套统一的编码。&lt;/p&gt;
&lt;p&gt;对于单个字符的编码，Python提供了 &lt;code&gt;Ord()&lt;/code&gt; 函数获取字符的整数表示，&lt;code&gt;chr()&lt;/code&gt; 函数通过整数获取对应字符。&lt;/p&gt;
&lt;p&gt;Python中的字符串类型为 &lt;code&gt;str&lt;/code&gt; ，一个字符对应若干字节。**如果要在网络上传输，或者保存到磁盘上，就需要把&lt;code&gt;str&lt;/code&gt;变为以字节为单位的&lt;code&gt;bytes&lt;/code&gt;。**Python对&lt;code&gt;bytes&lt;/code&gt;类型的数据用带&lt;code&gt;b&lt;/code&gt;前缀的单引号或双引号表示。&lt;/p&gt;
&lt;p&gt;我们可以通过&lt;code&gt;encode(&#39;编码方式&#39;)&lt;/code&gt; 将 &lt;strong&gt;str&lt;/strong&gt; 转变成 &lt;strong&gt;bytes&lt;/strong&gt; 。我们也可以通过 &lt;code&gt;decode(&#39;编码方式&#39;)&lt;/code&gt; 将 &lt;strong&gt;bytes&lt;/strong&gt; 转变为 &lt;strong&gt;str&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;Python为我们提供了一个 &lt;code&gt;len()&lt;/code&gt; 函数，如果字符串是 &lt;strong&gt;str&lt;/strong&gt; ，那么计算出的是字符数，如果是 &lt;strong&gt;bytes&lt;/strong&gt; ，那么计算的是字节数。我们为了防止乱码问题，在两者相互转换时推荐用 &lt;strong&gt;utf-8&lt;/strong&gt; 编码。&lt;/p&gt;
&lt;p&gt;由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;ch&#34;&gt;#!/usr/bin/env python3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;# -*- coding: utf-8 -*-&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；&lt;/p&gt;
&lt;p&gt;第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。而且需要你的编辑器支持 UTF-8编码。&lt;/p&gt;
&lt;h4 id=&#34;字符串的格式化输出&#34;&gt;字符串的格式化输出&lt;/h4&gt;
&lt;h5 id=&#34;第一种方式&#34;&gt;第一种方式&lt;/h5&gt;
&lt;p&gt;Python的 &lt;code&gt;print()&lt;/code&gt; 格式化输出和C语言的很像，也是 &lt;code&gt;%d&lt;/code&gt; 代表整数，&lt;code&gt;%f&lt;/code&gt; 代表浮点数， &lt;code&gt;%s&lt;/code&gt; 代表字符串，&lt;code&gt;%s&lt;/code&gt;代表十六进制整数。关于格式的指定，好比补0什么的也和C的很像。具体格式如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%2d&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%02d&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 3-01&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;my name is &lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%s&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 my name is zs&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;如果我们要在字符串里面输出 &lt;code&gt;%&lt;/code&gt; ，那么就需要用 &lt;code&gt;%%&lt;/code&gt; 来转义表示 &lt;code&gt;%&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;This is a common &lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%%&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt; &lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%s&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt; &amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;字符&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 This is a common % 字符&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h5 id=&#34;第二种方式&#34;&gt;第二种方式&lt;/h5&gt;
&lt;p&gt;除了上面的方法，&lt;code&gt;print&lt;/code&gt; 还可以用 .format 的方法进行格式化输出。例如下例子&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;{0}&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt; name is &lt;/span&gt;&lt;span class=&#34;si&#34;&gt;{1}&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;format&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;who&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;#输出 who name is zs&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;list--tuple-列表和元组&#34;&gt;List &amp;amp; tuple (列表和元组)&lt;/h3&gt;
&lt;h4 id=&#34;list列表&#34;&gt;List(列表)&lt;/h4&gt;
&lt;p&gt;List像是一个大杂烩，里面可以有各种类型的东西，是一个有序的集合，也就是说可以通过下标索引。&lt;/p&gt;
&lt;p&gt;我们创建一个列表可以用中括号， &lt;code&gt;Mylist = [&amp;quot;zs&amp;quot;,&amp;quot;wx&amp;quot;]&lt;/code&gt; ，这就创建了具有两个元素的列表，第一个元素是字符串 &lt;strong&gt;zs&lt;/strong&gt; 第二个元素是字符串 &lt;strong&gt;wx&lt;/strong&gt; 。这个列表的名字就是 &lt;strong&gt;Mylist&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;我们可以通过 &lt;code&gt;len()&lt;/code&gt; 来获取列表中元素的个数，也可以通过下表索引列表的元素，但是要注意下标是从0开始计数的，如果索引出界会报 &lt;code&gt;IndexError&lt;/code&gt; 。有趣的是，我们可以通过负的下表来访问元素，是倒着访问的，好比上述列表中 &lt;code&gt;Mylist[-1]&lt;/code&gt; 就代表元素 &lt;strong&gt;&amp;ldquo;wx&amp;rdquo;&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;我们可以通过 &lt;code&gt;listk = []&lt;/code&gt; ，来创建一个空列表 &lt;strong&gt;listk&lt;/strong&gt; ，如果用 &lt;code&gt;len()&lt;/code&gt; 查看长度那么长度为&lt;strong&gt;0&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;此外列表中的元素也可以是列表，可以通过&lt;strong&gt;类似于二维数组的形式索引&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;列表中，有许多的&lt;strong&gt;方法&lt;/strong&gt;。就像是相对于这个类型内置的一些函数，用法如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;wx&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 [&amp;#39;zs&amp;#39;, &amp;#39;wx&amp;#39;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;append&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;Better&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 用于在列表后面追加一个元素&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 [&amp;#39;zs&amp;#39;, &amp;#39;wx&amp;#39;, &amp;#39;Better&amp;#39;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;insert&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;Good&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 用于在下标为1的位置，插入一个元素&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 [&amp;#39;zs&amp;#39;, &amp;#39;Good&amp;#39;, &amp;#39;wx&amp;#39;, &amp;#39;Better&amp;#39;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;popx&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pop&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 用于删除列表中最后一个元素，并返回元素的值&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;popx&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 [&amp;#39;zs&amp;#39;, &amp;#39;Good&amp;#39;, &amp;#39;wx&amp;#39;] Better&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;popx&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;pop&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 用于删除列表中下标为1的元素，并返回元素的值&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;popx&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 [&amp;#39;zs&amp;#39;, &amp;#39;wx&amp;#39;] Good&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 创建了一个空列表 L&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;#输出0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;tuple元组&#34;&gt;Tuple(元组)&lt;/h4&gt;
&lt;p&gt;元组跟上面的链表差不多，只不过是&lt;strong&gt;不可变的，一旦初始化就不能修改&lt;/strong&gt;，也是可以通过下标访问元素。&lt;/p&gt;
&lt;p&gt;不同的的是，我们定义一个元组是用 &lt;code&gt;()&lt;/code&gt; ，好比我们定义 &lt;code&gt;Mytuple = (&amp;quot;zs&amp;quot;,&amp;quot;wx&amp;quot;)&lt;/code&gt; ，这是含有两个字符串元素的元组，我们可以通过 &lt;code&gt;Mytuple = ()&lt;/code&gt; 来定义一个空的元组。&lt;/p&gt;
&lt;p&gt;需要注意的是，当我们定义一个只有一个元素的元组，如果我们写成 &lt;code&gt;Mytuple = (&amp;quot;zs&amp;quot;)&lt;/code&gt; ，那么Python会默认解析为这是一个字符串，把括号当初普通的括号，不解释成元组。 那么我们如何定义只有一个元素的元组呢，我们应该写 &lt;code&gt;Mytuple = (&amp;quot;zs&amp;quot;,)&lt;/code&gt; 这样就是只有一个元素的元组。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;元组中的不可变，是指它的指向不变&lt;/strong&gt;，那么如果好比元组的元素中有一个列表，那么其实这个元组中的列表的元素还是可以改变的。&lt;/p&gt;
&lt;h3 id=&#34;条件判断&#34;&gt;条件判断&lt;/h3&gt;
&lt;p&gt;条件判断是一个经典的语句。用于分支结构。&lt;/p&gt;
&lt;p&gt;用法跟C很像，不过 &lt;strong&gt;else if&lt;/strong&gt; 可以缩写为 &lt;strong&gt;elif&lt;/strong&gt; ，并且因为 &lt;strong&gt;if&lt;/strong&gt; ，&lt;strong&gt;else&lt;/strong&gt; , &lt;strong&gt;elif&lt;/strong&gt;  后面接的都是语句块，因此要加 &lt;code&gt;:&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;weight&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;120&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;weight&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;200&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;too fat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;elif&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;weight&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;100&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;too thin&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;else&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt; 
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;Good&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;循环语句&#34;&gt;循环语句&lt;/h3&gt;
&lt;p&gt;循环结构也是三大结构之一。&lt;/p&gt;
&lt;h4 id=&#34;for&#34;&gt;for&lt;/h4&gt;
&lt;p&gt;for语句是我C++中最喜欢循环语句。在Python中，他的写法变成了 &lt;code&gt;for x in something:&lt;/code&gt; ，下面接相应的循环语句块。这个 &lt;strong&gt;x&lt;/strong&gt; 是变量的名字，&lt;strong&gt;something&lt;/strong&gt; 是某一个容器，可以是列表可以是元组啥的，这个写法的意思就是 遍历 &lt;strong&gt;something&lt;/strong&gt; 中的每个元素，带入变量 &lt;strong&gt;x&lt;/strong&gt; 中，执行循环操作。&lt;/p&gt;
&lt;p&gt;我们通常配合 &lt;code&gt;range()&lt;/code&gt; 函数来执行循环操作，通过 &lt;code&gt;range(n)&lt;/code&gt; 可以生成从 &lt;strong&gt;[0,n)&lt;/strong&gt; 的整数。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;list&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#输出 0~10&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;while&#34;&gt;while&lt;/h4&gt;
&lt;p&gt;while语句也是和C语言差不多，当型循环，当满足条件时就执行循环，也记住不要忘记加 &lt;code&gt;:&lt;/code&gt; 。&lt;/p&gt;
&lt;h4 id=&#34;break--continue&#34;&gt;break &amp;amp; continue&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;break&lt;/strong&gt; 的作用是结束整个循环。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;continue&lt;/strong&gt; 的作用是跳过这一次循环。&lt;/p&gt;
&lt;h3 id=&#34;dict--set-字典和集合&#34;&gt;Dict &amp;amp; Set (字典和集合)&lt;/h3&gt;
&lt;h4 id=&#34;dict&#34;&gt;Dict&lt;/h4&gt;
&lt;p&gt;这个字典其实就是C语言中的 &lt;strong&gt;map&lt;/strong&gt; ，人家 Python 直接内置了，属实业界良心。其实就是利用键值对匹配，一个键对应一个值。实现方式为哈希 &lt;strong&gt;(Hash)&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;创建就是 &lt;code&gt;Mydict = {&amp;quot;zs&amp;quot;:250 , &amp;quot;wx&amp;quot;:666&lt;/code&gt;} 这样第一个元素的键为 &amp;ldquo;zs&amp;rdquo; ，对应值为 250 。第二个值与这个的解读类似。我们也可以通过类似于数组的形式往字典里面加元素. &lt;code&gt;Mydict[&amp;quot;jjh&amp;quot;] = 100&lt;/code&gt;  ，那么这时候就往里面加入了一个键值对。&lt;/p&gt;
&lt;p&gt;字典中每个键值是唯一的，但是值可以相同，类似于函数。我们也可以通过类似于数组的形式，下标为键来访问值。当我们下标在字典中不存在，利用下标访问就会直接报错。&lt;strong&gt;Python&lt;/strong&gt; 为我们提供了另一种方法来满足我们的需求，利用 &lt;code&gt;Mydict.get(键)&lt;/code&gt; 可以获得对应的值，当不存在这个键，会返回 &lt;code&gt;None&lt;/code&gt; 。此外，我们也可以指定其返回值，&lt;code&gt;Mydict.get(键,something)&lt;/code&gt; ，这样当不存在的时候就会返回这个 &lt;strong&gt;something&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;最后，&lt;strong&gt;字典中的 Key 只能是不可变对象。&lt;/strong&gt;&lt;/p&gt;
&lt;h4 id=&#34;set&#34;&gt;Set&lt;/h4&gt;
&lt;p&gt;set 就是数学中的集合，具有无序性和唯一性。里面元素不重复，并且无序导致没法通过下标访问。可以用来给一组数据去重。通过 &lt;code&gt;add(key)  remove(key)&lt;/code&gt; 等函数去除对应值的元素。&lt;/p&gt;
&lt;p&gt;可以通过 &lt;code&gt;&amp;amp;&lt;/code&gt; 求交集， &lt;code&gt;|&lt;/code&gt; 求并集， &lt;code&gt;-&lt;/code&gt; 求差集等。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;set 中的元素也只能是不可变对象。&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;函数&#34;&gt;函数&lt;/h2&gt;
&lt;h3 id=&#34;调用函数&#34;&gt;调用函数&lt;/h3&gt;
&lt;p&gt;调用函数的时候要保证&lt;strong&gt;参数个数、参数顺序、参数类型&lt;/strong&gt;满足函数的定义。然后正确的处理好返回值。&lt;/p&gt;
&lt;h3 id=&#34;定义函数&#34;&gt;定义函数&lt;/h3&gt;
&lt;h4 id=&#34;函数的定义&#34;&gt;函数的定义&lt;/h4&gt;
&lt;p&gt;普通函数的定义通过 &lt;code&gt;def&lt;/code&gt; 来进行，好比我们要写一个求绝对值的函数，那么就可以如下定义&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;myabs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这样我们就可以类似调用 &lt;code&gt;myabs(-5)&lt;/code&gt; 来获得 -5 的绝对值。&lt;/p&gt;
&lt;p&gt;如果我们想要定义一个&lt;strong&gt;空的函数&lt;/strong&gt;，也就是什么都不做，那么函数内部的语句可以写 &lt;code&gt;pass&lt;/code&gt; 。这类似于C++中的分号的作用？大概是。&lt;/p&gt;
&lt;p&gt;通过  &lt;code&gt;函数.__name__&lt;/code&gt;  可以获得函数的真实名字。&lt;/p&gt;
&lt;h4 id=&#34;多个返回值的函数&#34;&gt;多个返回值的函数&lt;/h4&gt;
&lt;p&gt;我们可以在 &lt;strong&gt;return&lt;/strong&gt; 后面写多个参数，这样在返回的时候会返回一个元组。我们接受返回值的时候，也可以并拍写多个变量，这样就会把返回值的元组中的各个值依次赋给每个变量。&lt;/p&gt;
&lt;h3 id=&#34;函数的参数&#34;&gt;函数的参数&lt;/h3&gt;
&lt;p&gt;Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数，可变参数，关键字参数，这使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。&lt;/p&gt;
&lt;h4 id=&#34;默认参数&#34;&gt;默认参数&lt;/h4&gt;
&lt;p&gt;当我们调用一个函数，有几个参数大多数情况下是一个默认的值，少数时候是变的，那么我们可以用到默认参数，默认参数的使用我们可以在那个参数的后面加上 &lt;code&gt;=something&lt;/code&gt; ，这意思说是，这个参数默认为 &lt;strong&gt;something&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;poww&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;例如上面这个例子，我们要求 $2^5$ ，那么可以调用 &lt;code&gt;poww(2,5)&lt;/code&gt; 。那么我们如果要求 $2^2$ ，那么就可以直接调用&lt;code&gt;poww(2)&lt;/code&gt; ，另一个参数可以不写，那么就是默认的2。&lt;/p&gt;
&lt;p&gt;需要注意的是，&lt;strong&gt;必选参数在前，默认参数要在后&lt;/strong&gt;。否则话会产生歧义，因为解释器不知道你到底传入的参数是默认参数还是必选参数。&lt;/p&gt;
&lt;p&gt;此外，当我们有多个默认参数的时候，我们要在前面几个默认参数使用默认值，而后面那个用传入参数的时候，我们需要加上参数名，也就是 &lt;code&gt;参数名 = value&lt;/code&gt; 这样传入。例子如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;poww&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;z&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;+&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;z&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;f&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这时候，我们如果要调用 &lt;code&gt;poww(5,4)&lt;/code&gt; ，代表求的是 $5^{4+3}$ ，如果我们要求 $5^{2+7}$ ，可以按照如下方法调用，使用 &lt;code&gt;poww(5,z=7)&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;最后还有一点很重要，默认参数要指向 &lt;strong&gt;不变对象&lt;/strong&gt; 。否则当我们重复调用会发生错误。&lt;/p&gt;
&lt;h4 id=&#34;可变参数&#34;&gt;可变参数&lt;/h4&gt;
&lt;p&gt;我们很多时候可能需要一个函数内传入不定量个数的参数，这就要用到可变参数，可变参数就是数量可变。&lt;/p&gt;
&lt;p&gt;我们很容易想到，可以往里面传&lt;strong&gt;列表或者元组&lt;/strong&gt; ，不过这样当我们传之前还有要把所有的参数归到一个列表和元素中，这样太麻烦。Python给出了一个简便写法，我们只需要在参数面前加一个 &lt;code&gt;*&lt;/code&gt; ，这样我们就可以传入可变个参数。而且调用的时候，按普通的调用方法来即可，不需要传入元组。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;test&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;numbers&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;numbers&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;test&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 14&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么当这时候我们想往里面传一个元组，或者列表。当然可以挨个用数组访问然后写，不过Python也给了我们一个简便做法，只需要在列表或者元组前面加一个 &lt;code&gt;*&lt;/code&gt; ，就可以把它结构解开，然后挨个元素传入函数中。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;test&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;numbers&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;numbers&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;i&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;sum&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;list&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;test&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mylist&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;#输出30&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;关键词参数&#34;&gt;关键词参数&lt;/h4&gt;
&lt;p&gt;可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;myfun&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;**&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;kw&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;kw&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;myfun&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;city&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;jz&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;name&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 {&amp;#39;city&amp;#39;: &amp;#39;jz&amp;#39;, &amp;#39;name&amp;#39;: &amp;#39;zs&amp;#39;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;Mydict&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;city&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;jz&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;name&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;myfun&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;**&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;Mydict&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 输出 {&amp;#39;city&amp;#39;: &amp;#39;jz&amp;#39;, &amp;#39;name&amp;#39;: &amp;#39;zs&amp;#39;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;参数前面加 &lt;code&gt;**&lt;/code&gt; 即是关键词参数。当然我们也可以传入参数时，用dict，然后加 &lt;code&gt;**&lt;/code&gt;  解开结构传入。&lt;/p&gt;
&lt;h4 id=&#34;命名关键词参数&#34;&gt;命名关键词参数&lt;/h4&gt;
&lt;p&gt;我们可以在上述的基础上，传入特定的参数，给相应的参数命名。这需要我们在定义各个参数之前，在参数之前加上 &lt;code&gt;*&lt;/code&gt; ，好比 &lt;code&gt;def person(name,age,*,city,job)&lt;/code&gt; 规定了，我们传入的两个关键词参数名字只能是 &lt;strong&gt;city&lt;/strong&gt; 和和 &lt;strong&gt;job&lt;/strong&gt; 。不过，当我们前面有一个参数是可变参数，那么就可以不用加那个 &lt;code&gt;*&lt;/code&gt; 。好比像如下方法定义上面那个函数， &lt;code&gt;def person(name,age,*city,job)&lt;/code&gt; 。在这里 &lt;strong&gt;city&lt;/strong&gt; 是一个可变参数，后面的 &lt;strong&gt;job&lt;/strong&gt; 就是一个命名关键词参数。&lt;/p&gt;
&lt;h4 id=&#34;参数调用顺序&#34;&gt;参数调用顺序&lt;/h4&gt;
&lt;p&gt;在函数的参数中，上述各类参数可以组合使用。但是要注意顺序必须是：&lt;strong&gt;必选参数、默认参数、可变参数、命名关键字参数和关键字参数。&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;函数的递归调用&#34;&gt;函数的递归调用&lt;/h3&gt;
&lt;p&gt;函数的递归调用就是自己调用自己，QAQ，C++里面搞得也挺多的，就不赘述了。&lt;/p&gt;
&lt;h2 id=&#34;高级特性&#34;&gt;高级特性&lt;/h2&gt;
&lt;h3 id=&#34;切片&#34;&gt;切片&lt;/h3&gt;
&lt;p&gt;切片操作感觉真的是Python很方便的一个特性了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;字符串，列表，元组支持切片。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;好比我们有一个列表，里面有数，0~100，我们要取其中的奇数，那么我们就需要每隔一个数取一个数，我们可以通过for循环来实现这个操作，但是呢，Python有一种更便利的方法来实现，那就是切片。他的用法类似于matlab中的冒号表达式，&lt;code&gt;begin:end:step&lt;/code&gt;  这三个变量分别代表起始，终止和步长，也就是每个多少取一个，这三个参数都可以省略，&lt;strong&gt;省略时默认为序列起始点，序列终止点，1。这里要注意&lt;/strong&gt;，&lt;strong&gt;序列范围为 &lt;code&gt;[begin,end)&lt;/code&gt; ，前闭后开&lt;/strong&gt;，例子：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;list&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;101&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;100&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出0~100所有的奇数&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;::&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 从倒数第十个数开始输出奇数，输出 [91, 93, 95, 97, 99]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;50&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 从倒数第50个数，往前开始输出奇数，为 51~0中所有奇数&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;迭代&#34;&gt;迭代&lt;/h3&gt;
&lt;p&gt;迭代就是类似于遍历吧，通过 &lt;strong&gt;for&lt;/strong&gt; 可以迭代遍历一个容器内的所有元素。&lt;/p&gt;
&lt;p&gt;字符串和列表，元组，集合，字典这些都是可以用&lt;strong&gt;for&lt;/strong&gt;遍历的，这也叫做可迭代对象。需要注意的是，我们在遍历字典和集合时，因为是无序的，所以两次遍历顺序可能不太一样。&lt;/p&gt;
&lt;p&gt;当我们遍历字典时，默认遍历的是键值。例如下面这样&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;zs&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;rj&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;jjh&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;nb&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;key&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 输出 zs jjh&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;value&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;():&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;value&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 rj nb&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;items&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;():&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;v&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 zs rj jjh nb&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以注意到，可以同时迭代两个数，或者多个数。&lt;/p&gt;
&lt;h3 id=&#34;列表生成器&#34;&gt;列表生成器&lt;/h3&gt;
&lt;p&gt;列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。&lt;/p&gt;
&lt;p&gt;好比我们生成 &lt;code&gt;[1*1,2*2,3*3,···,n*n]&lt;/code&gt; 这样的列表，可以用循环实现，也可以用列表生成式。&lt;/p&gt;
&lt;p&gt;列表生成式格式大概是 &lt;code&gt;[元素 规则]&lt;/code&gt; 就是前面是要往里面加的元素的表达式，后面是生成的规则。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;L&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 输出[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;D&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;D&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;c1&#34;&gt;# 输出[4, 16, 36, 64, 100]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;生成器&#34;&gt;生成器&lt;/h3&gt;
&lt;p&gt;我们将上述列表生成式外面的 &lt;code&gt;[]&lt;/code&gt; 改成 &lt;code&gt;()&lt;/code&gt; ，就变成了一个列表生成器。列表生成器里面每个元素不是原来就存在的，而是你要用的时候他按照规则去生成，可以节省空间。他也是一个可迭代对象，可以通过for循环来访问，此外也可以用 &lt;code&gt;next(迭代器)&lt;/code&gt; 来获取下一个元素。&lt;/p&gt;
&lt;p&gt;除了上述方法，我们也可以用函数的方法来定义生成器，当一个函数中有了关键字 ： &lt;code&gt;yield&lt;/code&gt; 他就不是一个普通的函数了，就变成了一个生成器，按照函数的规则来生成相应数据。规则如下：当我们进入函数的时候，开始从头开始执行，执行到 &lt;strong&gt;yield&lt;/strong&gt; ，函数结束，返回 &lt;strong&gt;yield&lt;/strong&gt; 后面接的内容。然后下次进入函数的时候，从上次结束的地方继续开始，然后这样一直循环，直到再不能取数为止。&lt;/p&gt;
&lt;h3 id=&#34;迭代器&#34;&gt;迭代器&lt;/h3&gt;
&lt;p&gt;凡是可作用于&lt;code&gt;for&lt;/code&gt;循环的对象都是&lt;code&gt;Iterable&lt;/code&gt;类型，就是可迭代对象；&lt;/p&gt;
&lt;p&gt;凡是可作用于&lt;code&gt;next()&lt;/code&gt;函数的对象都是&lt;code&gt;Iterator&lt;/code&gt;类型，它们表示一个惰性计算的序列，&lt;strong&gt;这感觉就像是一个指针呀其实（自我认为），可以通过指针访问可迭代对象中的元素&lt;/strong&gt;；&lt;/p&gt;
&lt;p&gt;集合数据类型如&lt;code&gt;list&lt;/code&gt;、&lt;code&gt;dict&lt;/code&gt;、&lt;code&gt;str&lt;/code&gt;等是&lt;code&gt;Iterable&lt;/code&gt;但不是&lt;code&gt;Iterator&lt;/code&gt;，不过可以通过&lt;code&gt;iter()&lt;/code&gt;函数获得一个&lt;code&gt;Iterator&lt;/code&gt;对象。&lt;/p&gt;
&lt;p&gt;Python的&lt;code&gt;for&lt;/code&gt;循环本质上就是通过不断调用&lt;code&gt;next()&lt;/code&gt;函数实现的，例如：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;ow&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;pass&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实际上完全等价于：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;# 首先获得Iterator对象:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;it&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;iter&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;([&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;# 循环:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;True&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;try&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;# 获得下一个值:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;next&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;it&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;except&lt;/span&gt; &lt;span class=&#34;ne&#34;&gt;StopIteration&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;# 遇到StopIteration就退出循环&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;函数式编程&#34;&gt;函数式编程&lt;/h2&gt;
&lt;h3 id=&#34;高阶函数&#34;&gt;高阶函数&lt;/h3&gt;
&lt;h4 id=&#34;mapreduce&#34;&gt;map/reduce&lt;/h4&gt;
&lt;p&gt;&lt;code&gt;map()&lt;/code&gt; 函数包括两个参数，第一个参数是一个函数，第二个参数是一个序列。&lt;strong&gt;map&lt;/strong&gt; 的作用就是将序列中的每个元素代入到函数中并且求出每个元素对应的值，然后会返回一个相应的 &lt;code&gt;Iterator &lt;/code&gt; ，我们可以通过对应的语句，好比 &lt;code&gt;list()&lt;/code&gt; ，&lt;code&gt;tuple()&lt;/code&gt; 啥的转成对应的序列。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;reduce()&lt;/code&gt; 函数也是包括两个参数，一个是函数，一个是序列。&lt;strong&gt;reduce&lt;/strong&gt; 的作用是类似于一个递归的感觉吧大概，好比序列是 &lt;code&gt;L = [1,2,3,4,5]&lt;/code&gt; ，有一个函数是 &lt;code&gt;f&lt;/code&gt; ，我们暂且不管这个函数的作用是什么，那么如果我们现在调用 &lt;code&gt;reduce(f,L)&lt;/code&gt; ，他返回一个 &lt;code&gt;f&lt;/code&gt; 函数的返回值，值为 &lt;code&gt;f(f(f(1,2),3),4)&lt;/code&gt; 。就是类似于这种嵌套的结构。&lt;/p&gt;
&lt;h4 id=&#34;filter&#34;&gt;filter&lt;/h4&gt;
&lt;p&gt;&lt;code&gt;filter()&lt;/code&gt; 函数也包括两个参数，一个是函数，一个是序列。他是通过那个函数的返回值是 &lt;code&gt;True&lt;/code&gt; or &lt;code&gt;False&lt;/code&gt; 来判断是否保留那个序列中的每个元素。返回值也是 &lt;code&gt;Iterator&lt;/code&gt; 。&lt;/p&gt;
&lt;h4 id=&#34;sorted&#34;&gt;sorted&lt;/h4&gt;
&lt;p&gt;&lt;code&gt;sorted()&lt;/code&gt; 顾名思义，这是一个排序函数，我们往里面传入一个序列，那么他就会默认的对序列按升序排序，并且返回一个这个排序后序列。&lt;strong&gt;但是我们传入的序列不会有变动。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;此外，&lt;code&gt;sorted()&lt;/code&gt; 里面还可以加关键词 key 键值来确定规则，好比我们可以加 &lt;code&gt;key=abs&lt;/code&gt; 这样就可以将序列中所有的元素按照绝对值从小到大的顺序。我们也可以加 &lt;code&gt;reverse=True&lt;/code&gt; 来变成降序排序。&lt;/p&gt;
&lt;h3 id=&#34;返回函数&#34;&gt;返回函数&lt;/h3&gt;
&lt;p&gt;我们知道，函数名只是一个指向函数的变量，我们也可以用另一个变量指向这个函数来引用函数，相当于起了一个别名。因此，我们也可以在函数的返回值中返回一个函数，然后将返回值赋值给一个变量，这样就可以通过这个变量来调用返回的函数。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;我们在一个函数中又定义了一个函数，并且，内部函数可以引用外部函数的参数和局部变量，当外部函数返回内部函数时，相关参数和变量都保存在返回的函数中，这种称为“闭包**（Closure）**”的程序结构拥有极大的威力。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。因为这个变量相当于一个静态变量，现在变了，前面相应的结果也会变。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;通过  &lt;code&gt;函数.__name__&lt;/code&gt;  可以获得函数的真实名字。&lt;/p&gt;
&lt;h3 id=&#34;匿名函数&#34;&gt;匿名函数&lt;/h3&gt;
&lt;p&gt;通过 &lt;code&gt;lambda&lt;/code&gt; 可以创建匿名函数，这个就类似于matlab里面的那个 &lt;code&gt;@&lt;/code&gt; 创建的匿名函数。&lt;/p&gt;
&lt;p&gt;格式为： &lt;code&gt;lambda 变量: 返回值&lt;/code&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;list&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;map&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;lambda&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;我们也可以把匿名函数当作函数的返回值返回。&lt;/p&gt;
&lt;h3 id=&#34;装饰器&#34;&gt;装饰器&lt;/h3&gt;
&lt;p&gt;我们可能想在调用函数之前在前面打印一下函数的运行日志，或者其他的一些内容，其他的操作。&lt;/p&gt;
&lt;p&gt;这样我们就可以通过装饰器来实现，装饰器是为了给函数加一些其他的修饰，但是不需要在原本函数的基础上做改变。&lt;/p&gt;
&lt;p&gt;本质上，&lt;strong&gt;装饰器(decorator)&lt;/strong&gt; 是一个返回函数的高阶函数，一个能打印日志的 &lt;strong&gt;decorator&lt;/strong&gt; 可以如下定义：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;log&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;func&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;wrapper&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;args&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;**&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;kw&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;call &lt;/span&gt;&lt;span class=&#34;si&#34;&gt;%s&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;()&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;func&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;vm&#34;&gt;__name__&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;func&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;*&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;args&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;**&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;kw&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;wrapper&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;调用如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nd&#34;&gt;@log&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;k&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;nf&#34;&gt;now&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;():&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;	&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;2020-4-18&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;now&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;())&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 输出 call now() 2020-4-18&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这里， &lt;code&gt;@log&lt;/code&gt; 可以等效为 &lt;code&gt;now = log(now)&lt;/code&gt; ，那么我们应该怎么理解呢，首先，在我们调用之前，我们就把这个函数传入这个&lt;code&gt;log&lt;/code&gt;函数，然后进入 &lt;code&gt;wrapper&lt;/code&gt; 函数，先输出了日志，然后返回了一个 &lt;code&gt;func()&lt;/code&gt; 函数，然后结束这个函数的定义，又返回了 &lt;code&gt;wrapper&lt;/code&gt; 函数，这样就是将日志和原函数组合在一起了。所以最后一起输出&lt;/p&gt;
&lt;h3 id=&#34;偏函数&#34;&gt;偏函数&lt;/h3&gt;
&lt;p&gt;偏函数可以看做一个函数其中某一个参数固定，然后另成一个新函数，这样到时候我们重复调用的时候就会比较方便了。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当函数的参数个数太多，需要简化时，使用&lt;code&gt;functools.partial&lt;/code&gt;可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;当用 &lt;code&gt;functools.partial&lt;/code&gt; 之前我们需要引入 &lt;code&gt;functools&lt;/code&gt; 模块。&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kn&#34;&gt;import&lt;/span&gt; &lt;span class=&#34;nn&#34;&gt;functools&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;n&#34;&gt;int2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;n&#34;&gt;functools&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;partial&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;base&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;10110&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;base&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 以二进制来转化这个字符串，得到22&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nb&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;n&#34;&gt;int2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;10110&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;# 和上述等价&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;模块&#34;&gt;模块&lt;/h2&gt;
&lt;p&gt;这个就是类似于头文件的感觉，模块里面包含了很多别人已经写好了的函数，你引入之后可以直接拿来用，能够大大提高自己的编程效率。&lt;/p&gt;
&lt;p&gt;模块是放在包里的，这样可以避免不同模块之间的冲突，包中可以有很多的模块，并且所有包里都有一个相同名字的模块 ， &lt;code&gt;__init__.py&lt;/code&gt; ，这个文件说明这个目录是一个包，里面的其他的内容是模块。&lt;/p&gt;
&lt;p&gt;模块命名为 &lt;code&gt;包名.模块名&lt;/code&gt; ，这样就有效避免了模块与模块之间的冲突&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。&lt;/p&gt;
&lt;p&gt;创建自己的模块时，要注意：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;模块名要遵循Python变量命名规范，不要使用中文、特殊字符；&lt;/li&gt;
&lt;li&gt;模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行&lt;code&gt;import abc&lt;/code&gt;，若成功则说明系统存在此模块。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;h3 id=&#34;使用模块&#34;&gt;使用模块&lt;/h3&gt;
&lt;p&gt;在使用模块之前只需要  &lt;code&gt;import 模块名&lt;/code&gt; ，就可以通过 &lt;strong&gt;模块名.方法&lt;/strong&gt; 的方式来调用这个模块里面的方法。&lt;/p&gt;
&lt;p&gt;当我们在命令行运行模块文件时，Python解释器把一个特殊变量&lt;code&gt;__name__&lt;/code&gt;置为&lt;code&gt;__main__&lt;/code&gt;，而如果在其他地方导入模块时，&lt;code&gt;if&lt;/code&gt;判断将失败，因此，这种&lt;code&gt;if&lt;/code&gt;测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。&lt;/p&gt;
&lt;h4 id=&#34;封装&#34;&gt;封装&lt;/h4&gt;
&lt;p&gt;在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过&lt;code&gt;_&lt;/code&gt;前缀来实现的。&lt;/p&gt;
&lt;p&gt;正常的函数和变量名是公开的（public）。但是外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。&lt;/p&gt;
&lt;h3 id=&#34;安装第三方模块&#34;&gt;安装第三方模块&lt;/h3&gt;
&lt;p&gt;我们用包管理工具  &lt;code&gt;pip&lt;/code&gt;  来安装第三方模块。&lt;/p&gt;
&lt;p&gt;安装一个模块只需要 &lt;code&gt;pip install 库名&lt;/code&gt; ，这样就成功安装了一个包了。&lt;/p&gt;
&lt;p&gt;此外，我们也可以直接安装 &lt;a href=&#34;https://www.anaconda.com/&#34;&gt;Anaconda&lt;/a&gt; ，这是一个基于Python的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把数十个第三方模块自动安装好了，非常简单易用。&lt;/p&gt;
&lt;p&gt;下载地址为 ： &lt;a href=&#34;https://www.anaconda.com/download/&#34;&gt;Anaconda官网&lt;/a&gt;&lt;/p&gt;
&lt;h3 id=&#34;模块搜索路径&#34;&gt;模块搜索路径&lt;/h3&gt;
&lt;p&gt;当我们加载一个模块时，Python会在指定路径搜索对应的模块文件，如果找不到就会返回错误。&lt;/p&gt;
&lt;p&gt;默认情况下，Python解释器会搜索当前目录，所有已安装的内置模块和第三方模块，搜索路径存放在  &lt;code&gt;sys&lt;/code&gt; 模块的 &lt;code&gt;path&lt;/code&gt; 变量中。我们可以通过 &lt;code&gt;sys.path&lt;/code&gt; 来查看。&lt;/p&gt;
&lt;p&gt;我们要改动这个目录，往里面添加我们需要的，有两个方法。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;直接通过 &lt;code&gt;sys.path.append()&lt;/code&gt; 添加对应的路径，但是运行结束后会失效。&lt;/li&gt;
&lt;li&gt;设置环境变量&lt;code&gt;PYTHONPATH&lt;/code&gt;，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径，Python自己本身的搜索路径不受影响。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;资料补充&#34;&gt;资料补充&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://www.liaoxuefeng.com/wiki/1016959663602400&#34;&gt;廖雪峰的Python教程&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.jianshu.com/p/62f155eb6ac5&#34;&gt;Anaconda介绍、安装及使用教程&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;</description>
      <content:encoded><![CDATA[<h1 id="python学习笔记">Python学习笔记</h1>
<h2 id="python的不同解释器">Python的不同解释器</h2>
<ol>
<li>
<p><strong>CPython</strong></p>
<p>这是自带的用C语言开发的解释器，因此叫CPython。它也是使用最广的Python解释器。</p>
</li>
<li>
<p><strong>IPython</strong></p>
<p>这是基于CPython之上的一个交互式解释器，只是相比于CPython多了交互上的优化。</p>
</li>
<li>
<p><strong>PyPy</strong></p>
<p>它的目标是执行速度。PyPy采用<a href="http://en.wikipedia.org/wiki/Just-in-time_compilation">JIT技术</a>，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。他与CPython略有不同。</p>
</li>
</ol>
<ol>
<li>
<p><strong>Jython</strong></p>
<p>这是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。</p>
</li>
<li>
<p><strong>IronPython</strong></p>
<p>这是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。</p>
</li>
</ol>
<h2 id="python基础">Python基础</h2>
<h3 id="简单的输入和输出io">简单的输入和输出(I/O)</h3>
<h4 id="输入">输入</h4>
<p>python提供了一个 <code>input()</code> 函数供我们输入使用，这读入的是字符串数据，并返回，可以将返回值存放在一个变量中。<strong>input</strong>函数中可以带字符串，这段字符串在输入前会打印在屏幕上，这使得我们具有很好的交互性，好比我们写:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">name</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">&#34;hello,friend! please input your name&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;The input name is &#34;</span><span class="p">,</span><span class="n">name</span><span class="p">)</span>
</span></span></code></pre></div><p>那么这时候我们运行上述程序，就会提示 <code>hello , friend! please input your name</code> ，这就提示我们应该输入名字。</p>
<p>这里需要注意的是，<code>input()</code> 函数读入的是一个字符串 <code>str</code> ，就算我们输入了整数他也是一个字符串，如果我们要用真正的整数，那么就需要用 <code>int()</code> 进行类型强制转换。如果其中不是合法的整数，那么会报错。</p>
<h4 id="输出">输出</h4>
<p>python中的输出函数是 <code>print()</code> ，这和 <strong>C++</strong> 的<code>printf</code> 差了一个f。我们在函数的参数中传入什么，他就会打印什么。好比我们写  <code>print(&quot;heelo,world&quot;) </code> ，那么运行就会打印 <code>hello,world</code>  在屏幕上。<code>print</code> 支持我们传入多个参数，好比 <code>printf(&quot;my name is&quot;,&quot;zs&quot;)</code> ，两两之间用逗号隔开，这在输出时会被解析成空格，也就是说两段字符串之间有一个空格。当然此函数也可以打印整数等。</p>
<h3 id="一些规则">一些规则</h3>
<h4 id="缩进">缩进</h4>
<p>Python中对代码块的区分，不是用C++的大括号，而是用缩进。处于连续同一缩进的是一个代码块，这也是为什么Python又被戏称为<strong>游标卡尺语言</strong>的原因。<strong>当语句以冒号<code>:</code>结尾时，缩进的语句视为代码块。<strong>我们通常用</strong>一个Tab / 四个空格</strong> 的缩进。</p>
<h4 id="注释">注释</h4>
<p>Python的注释用的是 <code>#</code> ，而 C++ 中的注释用的是 <code>\\</code> 。</p>
<h4 id="case-sensitive">Case Sensitive</h4>
<p>Python中是大小写敏感的，也就是 a 和 A 不是同一个东西。</p>
<h3 id="数据类型">数据类型</h3>
<h4 id="1-整数">1. 整数</h4>
<p>Python一个很大的好处就是可以处理任意大小的整数，包括负整数。这也是为什么很多大数题大家都喜欢用Python，hhhh。多数地方都用十进制，但是也是支持其他进制的哈~好比 <code>0x</code> 前缀就是16进制。</p>
<h4 id="2-浮点数">2. 浮点数</h4>
<p>浮点数是小数，之所以称为浮点数，是因为小数点位置在科学计数法中是可变的。这里需要注意，整数和浮点数在计算机内部存储方式不同，浮点数应该都是 <code>IEEE754</code> 标准吧？整数之间的运算永远都是精确的，包括除法。而浮点数的运算则会有一定的误差。Python的浮点数也没有大小限制，但是超出一定范围就直接表示为<code>inf</code>（无限大）。</p>
<h4 id="3-字符串">3. 字符串</h4>
<p>字符串是以单引号 <code>''</code> 或者双引号 <code>&quot;&quot;</code> 括起来的任意文本。我们注意到<strong>Python</strong>中<strong>没有单个字符的概念</strong>，就算是单个字符也是一个字符串。如果<code>''</code> 括起来的字符串内部出现 <code>''</code> 需要使用<code>\</code>转义，相同的，如果 <code>&quot;&quot;</code> 括起来的字符串内部出现 <code>&quot;&quot;</code> 需要转义。好比下面的程序</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;My name is &#39;zs&#39;&#34;</span><span class="p">)</span>  <span class="c1">#合法  My name is &#39;zs&#39;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;My name is &#34;</span><span class="n">zs</span><span class="s2">&#34;&#34;</span><span class="p">)</span>  <span class="c1">#不合法 invalid syntax</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;My name is </span><span class="se">\&#34;</span><span class="s2">zs</span><span class="se">\&#34;</span><span class="s2">&#34;</span><span class="p">)</span> <span class="c1">#合法 My name is &#34;zs&#34; </span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;My name is &#34;zs&#34;&#39;</span><span class="p">)</span>  <span class="c1">#合法  My name is &#34;zs&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;My name is &#39;</span><span class="n">zs</span><span class="s1">&#39;&#39;</span><span class="p">)</span>  <span class="c1">#不合法 invalid syntax</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;My name is </span><span class="se">\&#39;</span><span class="s1">zs</span><span class="se">\&#39;</span><span class="s1">&#39;</span><span class="p">)</span> <span class="c1">#合法 My name is &#39;zs&#39;</span>
</span></span></code></pre></div><p>Python中也有很多转义字符，跟C++的很类似。<code>\n</code>,<code>\t</code>,<code>\\</code>  分别代表换行，横向制表，字符<code>\</code>  。在python中还支持用 <code>r' '</code> 表示 <code>''</code>  内部的字符默认不转义。</p>
<p>Python在输出多行语句时，可以用 <code>print('''content''')</code> 其中content中的内容，支持用直觉上的换行。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;python
</span></span></span><span class="line"><span class="cl"><span class="s1">name
</span></span></span><span class="line"><span class="cl"><span class="s1">zs&#39;&#39;&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1"># The output</span>
</span></span><span class="line"><span class="cl"><span class="n">python</span>
</span></span><span class="line"><span class="cl"><span class="n">name</span>
</span></span><span class="line"><span class="cl"><span class="n">zs</span>
</span></span></code></pre></div><h4 id="4-布尔值">4. 布尔值</h4>
<p>含有 <strong>Ture</strong> 和 <strong>False</strong> 两种类型，代表真和假。支持 <code>and</code> ,  <code>or</code> ,<code>not</code> 三种运算。</p>
<h4 id="5-空值">5. 空值</h4>
<p>空值是Python中的一个特殊值，用 <code>None</code> 表示。 <code>None</code>不能理解为<code>0</code>，因为<code>0</code>是有意义的，而<code>None</code>是一个特殊的空值。</p>
<h3 id="变量">变量</h3>
<p>变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和<code>_</code>的组合，且不能用数字开头。</p>
<p>变量命名时最好能做到顾名思义，当然也有很多规范的命名规则，可以自行百度。</p>
<p>在 <strong>Python</strong> 中我们不需要指定一个变量是特定的类型，它可以在不同的类型之间变来变去，这确实很方便，不过感觉也是很占内存和时间的。</p>
<p>这种变量本身类型不固定的语言称之为<strong>动态语言</strong>，与之对应的是<strong>静态语言</strong>。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错</p>
<h3 id="常量">常量</h3>
<p>Python中没有C++中的const来限制常量，但是通常用<strong>变量名全大写来代表这个变量为一个常量</strong>，但是这玩意是个约定俗成的，并不是说你这么写他就真是个常量了。</p>
<h3 id="字符串和编码">字符串和编码</h3>
<h4 id="字符编码">字符编码</h4>
<p>字符编码有很多种，不同的语言也对应着不同的字符编码。常见的几个是 <code>ASCII</code> ,<code>Unicode</code> ,<code>UTF-8</code>,<code>GB2313</code> 他们分别是英文和特殊字符的编码，统一的一套编码，可变长的统一编码，常用的中文编码。</p>
<h4 id="python的字符串存储">Python的字符串存储</h4>
<p>Python 3的的字符串是 <code>Unicode</code> 编码的，也就是说Python的字符串支持多语言，因为这是一套统一的编码。</p>
<p>对于单个字符的编码，Python提供了 <code>Ord()</code> 函数获取字符的整数表示，<code>chr()</code> 函数通过整数获取对应字符。</p>
<p>Python中的字符串类型为 <code>str</code> ，一个字符对应若干字节。**如果要在网络上传输，或者保存到磁盘上，就需要把<code>str</code>变为以字节为单位的<code>bytes</code>。**Python对<code>bytes</code>类型的数据用带<code>b</code>前缀的单引号或双引号表示。</p>
<p>我们可以通过<code>encode('编码方式')</code> 将 <strong>str</strong> 转变成 <strong>bytes</strong> 。我们也可以通过 <code>decode('编码方式')</code> 将 <strong>bytes</strong> 转变为 <strong>str</strong> 。</p>
<p>Python为我们提供了一个 <code>len()</code> 函数，如果字符串是 <strong>str</strong> ，那么计算出的是字符数，如果是 <strong>bytes</strong> ，那么计算的是字节数。我们为了防止乱码问题，在两者相互转换时推荐用 <strong>utf-8</strong> 编码。</p>
<p>由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="ch">#!/usr/bin/env python3</span>
</span></span><span class="line"><span class="cl"><span class="c1"># -*- coding: utf-8 -*-</span>
</span></span></code></pre></div><p>第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；</p>
<p>第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。而且需要你的编辑器支持 UTF-8编码。</p>
<h4 id="字符串的格式化输出">字符串的格式化输出</h4>
<h5 id="第一种方式">第一种方式</h5>
<p>Python的 <code>print()</code> 格式化输出和C语言的很像，也是 <code>%d</code> 代表整数，<code>%f</code> 代表浮点数， <code>%s</code> 代表字符串，<code>%s</code>代表十六进制整数。关于格式的指定，好比补0什么的也和C的很像。具体格式如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%2d</span><span class="s1">-</span><span class="si">%02d</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">))</span> <span class="c1"># 输出 3-01</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;my name is </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="s2">&#34;zs&#34;</span><span class="p">)</span> <span class="c1"># 输出 my name is zs</span>
</span></span></code></pre></div><p>如果我们要在字符串里面输出 <code>%</code> ，那么就需要用 <code>%%</code> 来转义表示 <code>%</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;This is a common </span><span class="si">%%</span><span class="s2"> </span><span class="si">%s</span><span class="s2"> &#34;</span> <span class="o">%</span> <span class="s2">&#34;字符&#34;</span><span class="p">)</span> <span class="c1"># 输出 This is a common % 字符</span>
</span></span></code></pre></div><h5 id="第二种方式">第二种方式</h5>
<p>除了上面的方法，<code>print</code> 还可以用 .format 的方法进行格式化输出。例如下例子</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">{0}</span><span class="s1"> name is </span><span class="si">{1}</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="s2">&#34;who&#34;</span><span class="p">,</span><span class="s2">&#34;zs&#34;</span><span class="p">))</span> <span class="c1">#输出 who name is zs</span>
</span></span></code></pre></div><h3 id="list--tuple-列表和元组">List &amp; tuple (列表和元组)</h3>
<h4 id="list列表">List(列表)</h4>
<p>List像是一个大杂烩，里面可以有各种类型的东西，是一个有序的集合，也就是说可以通过下标索引。</p>
<p>我们创建一个列表可以用中括号， <code>Mylist = [&quot;zs&quot;,&quot;wx&quot;]</code> ，这就创建了具有两个元素的列表，第一个元素是字符串 <strong>zs</strong> 第二个元素是字符串 <strong>wx</strong> 。这个列表的名字就是 <strong>Mylist</strong> 。</p>
<p>我们可以通过 <code>len()</code> 来获取列表中元素的个数，也可以通过下表索引列表的元素，但是要注意下标是从0开始计数的，如果索引出界会报 <code>IndexError</code> 。有趣的是，我们可以通过负的下表来访问元素，是倒着访问的，好比上述列表中 <code>Mylist[-1]</code> 就代表元素 <strong>&ldquo;wx&rdquo;</strong> 。</p>
<p>我们可以通过 <code>listk = []</code> ，来创建一个空列表 <strong>listk</strong> ，如果用 <code>len()</code> 查看长度那么长度为<strong>0</strong>.</p>
<p>此外列表中的元素也可以是列表，可以通过<strong>类似于二维数组的形式索引</strong>。</p>
<p>列表中，有许多的<strong>方法</strong>。就像是相对于这个类型内置的一些函数，用法如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">Mylist</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;zs&#34;</span><span class="p">,</span><span class="s2">&#34;wx&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">Mylist</span><span class="p">)</span> <span class="c1"># 输出 [&#39;zs&#39;, &#39;wx&#39;]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">Mylist</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">&#39;Better&#39;</span><span class="p">)</span> <span class="c1"># 用于在列表后面追加一个元素</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">Mylist</span><span class="p">)</span> <span class="c1"># 输出 [&#39;zs&#39;, &#39;wx&#39;, &#39;Better&#39;]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">Mylist</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="s1">&#39;Good&#39;</span><span class="p">)</span> <span class="c1"># 用于在下标为1的位置，插入一个元素</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">Mylist</span><span class="p">)</span> <span class="c1"># 输出 [&#39;zs&#39;, &#39;Good&#39;, &#39;wx&#39;, &#39;Better&#39;]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">popx</span> <span class="o">=</span> <span class="n">Mylist</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span> <span class="c1"># 用于删除列表中最后一个元素，并返回元素的值</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">Mylist</span><span class="p">,</span><span class="n">popx</span><span class="p">)</span> <span class="c1"># 输出 [&#39;zs&#39;, &#39;Good&#39;, &#39;wx&#39;] Better</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">popx</span> <span class="o">=</span> <span class="n">Mylist</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># 用于删除列表中下标为1的元素，并返回元素的值</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">Mylist</span><span class="p">,</span><span class="n">popx</span><span class="p">)</span> <span class="c1"># 输出 [&#39;zs&#39;, &#39;wx&#39;] Good</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">L</span> <span class="o">=</span> <span class="p">[]</span> <span class="c1"># 创建了一个空列表 L</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">L</span><span class="p">))</span> <span class="c1">#输出0</span>
</span></span></code></pre></div><h4 id="tuple元组">Tuple(元组)</h4>
<p>元组跟上面的链表差不多，只不过是<strong>不可变的，一旦初始化就不能修改</strong>，也是可以通过下标访问元素。</p>
<p>不同的的是，我们定义一个元组是用 <code>()</code> ，好比我们定义 <code>Mytuple = (&quot;zs&quot;,&quot;wx&quot;)</code> ，这是含有两个字符串元素的元组，我们可以通过 <code>Mytuple = ()</code> 来定义一个空的元组。</p>
<p>需要注意的是，当我们定义一个只有一个元素的元组，如果我们写成 <code>Mytuple = (&quot;zs&quot;)</code> ，那么Python会默认解析为这是一个字符串，把括号当初普通的括号，不解释成元组。 那么我们如何定义只有一个元素的元组呢，我们应该写 <code>Mytuple = (&quot;zs&quot;,)</code> 这样就是只有一个元素的元组。</p>
<p><strong>元组中的不可变，是指它的指向不变</strong>，那么如果好比元组的元素中有一个列表，那么其实这个元组中的列表的元素还是可以改变的。</p>
<h3 id="条件判断">条件判断</h3>
<p>条件判断是一个经典的语句。用于分支结构。</p>
<p>用法跟C很像，不过 <strong>else if</strong> 可以缩写为 <strong>elif</strong> ，并且因为 <strong>if</strong> ，<strong>else</strong> , <strong>elif</strong>  后面接的都是语句块，因此要加 <code>:</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">weight</span> <span class="o">=</span> <span class="mi">120</span>
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="n">weight</span><span class="o">&gt;=</span><span class="mi">200</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;too fat&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="k">elif</span> <span class="n">weight</span><span class="o">&lt;=</span><span class="mi">100</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;too thin&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="k">else</span><span class="p">:</span> 
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;Good&#34;</span><span class="p">)</span>
</span></span></code></pre></div><h3 id="循环语句">循环语句</h3>
<p>循环结构也是三大结构之一。</p>
<h4 id="for">for</h4>
<p>for语句是我C++中最喜欢循环语句。在Python中，他的写法变成了 <code>for x in something:</code> ，下面接相应的循环语句块。这个 <strong>x</strong> 是变量的名字，<strong>something</strong> 是某一个容器，可以是列表可以是元组啥的，这个写法的意思就是 遍历 <strong>something</strong> 中的每个元素，带入变量 <strong>x</strong> 中，执行循环操作。</p>
<p>我们通常配合 <code>range()</code> 函数来执行循环操作，通过 <code>range(n)</code> 可以生成从 <strong>[0,n)</strong> 的整数。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">11</span><span class="p">)):</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>  <span class="c1">#输出 0~10</span>
</span></span></code></pre></div><h4 id="while">while</h4>
<p>while语句也是和C语言差不多，当型循环，当满足条件时就执行循环，也记住不要忘记加 <code>:</code> 。</p>
<h4 id="break--continue">break &amp; continue</h4>
<p><strong>break</strong> 的作用是结束整个循环。</p>
<p><strong>continue</strong> 的作用是跳过这一次循环。</p>
<h3 id="dict--set-字典和集合">Dict &amp; Set (字典和集合)</h3>
<h4 id="dict">Dict</h4>
<p>这个字典其实就是C语言中的 <strong>map</strong> ，人家 Python 直接内置了，属实业界良心。其实就是利用键值对匹配，一个键对应一个值。实现方式为哈希 <strong>(Hash)</strong> 。</p>
<p>创建就是 <code>Mydict = {&quot;zs&quot;:250 , &quot;wx&quot;:666</code>} 这样第一个元素的键为 &ldquo;zs&rdquo; ，对应值为 250 。第二个值与这个的解读类似。我们也可以通过类似于数组的形式往字典里面加元素. <code>Mydict[&quot;jjh&quot;] = 100</code>  ，那么这时候就往里面加入了一个键值对。</p>
<p>字典中每个键值是唯一的，但是值可以相同，类似于函数。我们也可以通过类似于数组的形式，下标为键来访问值。当我们下标在字典中不存在，利用下标访问就会直接报错。<strong>Python</strong> 为我们提供了另一种方法来满足我们的需求，利用 <code>Mydict.get(键)</code> 可以获得对应的值，当不存在这个键，会返回 <code>None</code> 。此外，我们也可以指定其返回值，<code>Mydict.get(键,something)</code> ，这样当不存在的时候就会返回这个 <strong>something</strong> 。</p>
<p>最后，<strong>字典中的 Key 只能是不可变对象。</strong></p>
<h4 id="set">Set</h4>
<p>set 就是数学中的集合，具有无序性和唯一性。里面元素不重复，并且无序导致没法通过下标访问。可以用来给一组数据去重。通过 <code>add(key)  remove(key)</code> 等函数去除对应值的元素。</p>
<p>可以通过 <code>&amp;</code> 求交集， <code>|</code> 求并集， <code>-</code> 求差集等。</p>
<p><strong>set 中的元素也只能是不可变对象。</strong></p>
<h2 id="函数">函数</h2>
<h3 id="调用函数">调用函数</h3>
<p>调用函数的时候要保证<strong>参数个数、参数顺序、参数类型</strong>满足函数的定义。然后正确的处理好返回值。</p>
<h3 id="定义函数">定义函数</h3>
<h4 id="函数的定义">函数的定义</h4>
<p>普通函数的定义通过 <code>def</code> 来进行，好比我们要写一个求绝对值的函数，那么就可以如下定义</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">myabs</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">x</span><span class="o">&gt;=</span><span class="mi">0</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl">    <span class="k">else</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="o">-</span><span class="n">x</span>
</span></span></code></pre></div><p>这样我们就可以类似调用 <code>myabs(-5)</code> 来获得 -5 的绝对值。</p>
<p>如果我们想要定义一个<strong>空的函数</strong>，也就是什么都不做，那么函数内部的语句可以写 <code>pass</code> 。这类似于C++中的分号的作用？大概是。</p>
<p>通过  <code>函数.__name__</code>  可以获得函数的真实名字。</p>
<h4 id="多个返回值的函数">多个返回值的函数</h4>
<p>我们可以在 <strong>return</strong> 后面写多个参数，这样在返回的时候会返回一个元组。我们接受返回值的时候，也可以并拍写多个变量，这样就会把返回值的元组中的各个值依次赋给每个变量。</p>
<h3 id="函数的参数">函数的参数</h3>
<p>Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数，可变参数，关键字参数，这使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。</p>
<h4 id="默认参数">默认参数</h4>
<p>当我们调用一个函数，有几个参数大多数情况下是一个默认的值，少数时候是变的，那么我们可以用到默认参数，默认参数的使用我们可以在那个参数的后面加上 <code>=something</code> ，这意思说是，这个参数默认为 <strong>something</strong></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">poww</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">n</span><span class="o">=</span><span class="mi">2</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">k</span> <span class="o">=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="n">n</span><span class="o">&gt;</span><span class="mi">0</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">n</span> <span class="o">=</span> <span class="n">n</span><span class="o">-</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="n">k</span> <span class="o">=</span> <span class="n">k</span><span class="o">*</span><span class="n">x</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">k</span>
</span></span></code></pre></div><p>例如上面这个例子，我们要求 $2^5$ ，那么可以调用 <code>poww(2,5)</code> 。那么我们如果要求 $2^2$ ，那么就可以直接调用<code>poww(2)</code> ，另一个参数可以不写，那么就是默认的2。</p>
<p>需要注意的是，<strong>必选参数在前，默认参数要在后</strong>。否则话会产生歧义，因为解释器不知道你到底传入的参数是默认参数还是必选参数。</p>
<p>此外，当我们有多个默认参数的时候，我们要在前面几个默认参数使用默认值，而后面那个用传入参数的时候，我们需要加上参数名，也就是 <code>参数名 = value</code> 这样传入。例子如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">poww</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">n</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span><span class="n">z</span><span class="o">=</span><span class="mi">3</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">k</span> <span class="o">=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="n">f</span> <span class="o">=</span> <span class="n">n</span><span class="o">+</span><span class="n">z</span>
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="n">n</span><span class="o">&gt;</span><span class="mi">0</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">f</span> <span class="o">=</span> <span class="n">f</span><span class="o">-</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="n">k</span> <span class="o">=</span> <span class="n">k</span><span class="o">*</span><span class="n">x</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">k</span>
</span></span></code></pre></div><p>这时候，我们如果要调用 <code>poww(5,4)</code> ，代表求的是 $5^{4+3}$ ，如果我们要求 $5^{2+7}$ ，可以按照如下方法调用，使用 <code>poww(5,z=7)</code> 。</p>
<p>最后还有一点很重要，默认参数要指向 <strong>不变对象</strong> 。否则当我们重复调用会发生错误。</p>
<h4 id="可变参数">可变参数</h4>
<p>我们很多时候可能需要一个函数内传入不定量个数的参数，这就要用到可变参数，可变参数就是数量可变。</p>
<p>我们很容易想到，可以往里面传<strong>列表或者元组</strong> ，不过这样当我们传之前还有要把所有的参数归到一个列表和元素中，这样太麻烦。Python给出了一个简便写法，我们只需要在参数面前加一个 <code>*</code> ，这样我们就可以传入可变个参数。而且调用的时候，按普通的调用方法来即可，不需要传入元组。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">test</span><span class="p">(</span><span class="o">*</span><span class="n">numbers</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="nb">sum</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">numbers</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="nb">sum</span> <span class="o">=</span> <span class="nb">sum</span> <span class="o">+</span> <span class="n">i</span><span class="o">*</span><span class="n">i</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nb">sum</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">test</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">))</span> <span class="c1"># 输出 14</span>
</span></span></code></pre></div><p>那么当这时候我们想往里面传一个元组，或者列表。当然可以挨个用数组访问然后写，不过Python也给了我们一个简便做法，只需要在列表或者元组前面加一个 <code>*</code> ，就可以把它结构解开，然后挨个元素传入函数中。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">test</span><span class="p">(</span><span class="o">*</span><span class="n">numbers</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="nb">sum</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">numbers</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="nb">sum</span> <span class="o">=</span> <span class="nb">sum</span> <span class="o">+</span> <span class="n">i</span><span class="o">*</span><span class="n">i</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nb">sum</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">Mylist</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">test</span><span class="p">(</span><span class="o">*</span><span class="n">Mylist</span><span class="p">))</span>  <span class="c1">#输出30</span>
</span></span></code></pre></div><h4 id="关键词参数">关键词参数</h4>
<p>可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">myfun</span><span class="p">(</span><span class="o">**</span><span class="n">kw</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="n">kw</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">myfun</span><span class="p">(</span><span class="n">city</span> <span class="o">=</span> <span class="s2">&#34;jz&#34;</span><span class="p">,</span><span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;zs&#34;</span><span class="p">)</span> <span class="c1"># 输出 {&#39;city&#39;: &#39;jz&#39;, &#39;name&#39;: &#39;zs&#39;}</span>
</span></span><span class="line"><span class="cl"><span class="n">Mydict</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&#34;city&#34;</span><span class="p">:</span><span class="s2">&#34;jz&#34;</span><span class="p">,</span><span class="s2">&#34;name&#34;</span><span class="p">:</span><span class="s2">&#34;zs&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="n">myfun</span><span class="p">(</span><span class="o">**</span><span class="n">Mydict</span><span class="p">)</span>  <span class="c1"># 输出 {&#39;city&#39;: &#39;jz&#39;, &#39;name&#39;: &#39;zs&#39;}</span>
</span></span></code></pre></div><p>参数前面加 <code>**</code> 即是关键词参数。当然我们也可以传入参数时，用dict，然后加 <code>**</code>  解开结构传入。</p>
<h4 id="命名关键词参数">命名关键词参数</h4>
<p>我们可以在上述的基础上，传入特定的参数，给相应的参数命名。这需要我们在定义各个参数之前，在参数之前加上 <code>*</code> ，好比 <code>def person(name,age,*,city,job)</code> 规定了，我们传入的两个关键词参数名字只能是 <strong>city</strong> 和和 <strong>job</strong> 。不过，当我们前面有一个参数是可变参数，那么就可以不用加那个 <code>*</code> 。好比像如下方法定义上面那个函数， <code>def person(name,age,*city,job)</code> 。在这里 <strong>city</strong> 是一个可变参数，后面的 <strong>job</strong> 就是一个命名关键词参数。</p>
<h4 id="参数调用顺序">参数调用顺序</h4>
<p>在函数的参数中，上述各类参数可以组合使用。但是要注意顺序必须是：<strong>必选参数、默认参数、可变参数、命名关键字参数和关键字参数。</strong></p>
<h3 id="函数的递归调用">函数的递归调用</h3>
<p>函数的递归调用就是自己调用自己，QAQ，C++里面搞得也挺多的，就不赘述了。</p>
<h2 id="高级特性">高级特性</h2>
<h3 id="切片">切片</h3>
<p>切片操作感觉真的是Python很方便的一个特性了。</p>
<p><strong>字符串，列表，元组支持切片。</strong></p>
<p>好比我们有一个列表，里面有数，0~100，我们要取其中的奇数，那么我们就需要每隔一个数取一个数，我们可以通过for循环来实现这个操作，但是呢，Python有一种更便利的方法来实现，那就是切片。他的用法类似于matlab中的冒号表达式，<code>begin:end:step</code>  这三个变量分别代表起始，终止和步长，也就是每个多少取一个，这三个参数都可以省略，<strong>省略时默认为序列起始点，序列终止点，1。这里要注意</strong>，<strong>序列范围为 <code>[begin,end)</code> ，前闭后开</strong>，例子：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">L</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">101</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">L</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">100</span><span class="p">:</span><span class="mi">2</span><span class="p">])</span> <span class="c1"># 输出0~100所有的奇数</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">L</span><span class="p">[</span><span class="o">-</span><span class="mi">10</span><span class="p">::</span><span class="mi">2</span><span class="p">])</span>  <span class="c1"># 从倒数第十个数开始输出奇数，输出 [91, 93, 95, 97, 99]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">L</span><span class="p">[</span><span class="o">-</span><span class="mi">50</span><span class="p">:</span><span class="mi">0</span><span class="p">:</span><span class="o">-</span><span class="mi">2</span><span class="p">])</span>  <span class="c1"># 从倒数第50个数，往前开始输出奇数，为 51~0中所有奇数</span>
</span></span></code></pre></div><h3 id="迭代">迭代</h3>
<p>迭代就是类似于遍历吧，通过 <strong>for</strong> 可以迭代遍历一个容器内的所有元素。</p>
<p>字符串和列表，元组，集合，字典这些都是可以用<strong>for</strong>遍历的，这也叫做可迭代对象。需要注意的是，我们在遍历字典和集合时，因为是无序的，所以两次遍历顺序可能不太一样。</p>
<p>当我们遍历字典时，默认遍历的是键值。例如下面这样</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">L</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&#34;zs&#34;</span><span class="p">:</span><span class="s2">&#34;rj&#34;</span><span class="p">,</span><span class="s2">&#34;jjh&#34;</span><span class="p">:</span><span class="s2">&#34;nb&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">L</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>  <span class="c1"># 输出 zs jjh</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">L</span><span class="o">.</span><span class="n">values</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="c1"># 输出 rj nb</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">k</span><span class="p">,</span><span class="n">v</span> <span class="ow">in</span> <span class="n">L</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="n">k</span><span class="p">,</span><span class="n">v</span><span class="p">)</span> <span class="c1"># 输出 zs rj jjh nb</span>
</span></span></code></pre></div><p>可以注意到，可以同时迭代两个数，或者多个数。</p>
<h3 id="列表生成器">列表生成器</h3>
<p>列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。</p>
<p>好比我们生成 <code>[1*1,2*2,3*3,···,n*n]</code> 这样的列表，可以用循环实现，也可以用列表生成式。</p>
<p>列表生成式格式大概是 <code>[元素 规则]</code> 就是前面是要往里面加的元素的表达式，后面是生成的规则。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">L</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="o">*</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">11</span><span class="p">)]</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">L</span><span class="p">)</span>  <span class="c1"># 输出[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">D</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="o">*</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">11</span><span class="p">)</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">D</span><span class="p">)</span>  <span class="c1"># 输出[4, 16, 36, 64, 100]</span>
</span></span></code></pre></div><h3 id="生成器">生成器</h3>
<p>我们将上述列表生成式外面的 <code>[]</code> 改成 <code>()</code> ，就变成了一个列表生成器。列表生成器里面每个元素不是原来就存在的，而是你要用的时候他按照规则去生成，可以节省空间。他也是一个可迭代对象，可以通过for循环来访问，此外也可以用 <code>next(迭代器)</code> 来获取下一个元素。</p>
<p>除了上述方法，我们也可以用函数的方法来定义生成器，当一个函数中有了关键字 ： <code>yield</code> 他就不是一个普通的函数了，就变成了一个生成器，按照函数的规则来生成相应数据。规则如下：当我们进入函数的时候，开始从头开始执行，执行到 <strong>yield</strong> ，函数结束，返回 <strong>yield</strong> 后面接的内容。然后下次进入函数的时候，从上次结束的地方继续开始，然后这样一直循环，直到再不能取数为止。</p>
<h3 id="迭代器">迭代器</h3>
<p>凡是可作用于<code>for</code>循环的对象都是<code>Iterable</code>类型，就是可迭代对象；</p>
<p>凡是可作用于<code>next()</code>函数的对象都是<code>Iterator</code>类型，它们表示一个惰性计算的序列，<strong>这感觉就像是一个指针呀其实（自我认为），可以通过指针访问可迭代对象中的元素</strong>；</p>
<p>集合数据类型如<code>list</code>、<code>dict</code>、<code>str</code>等是<code>Iterable</code>但不是<code>Iterator</code>，不过可以通过<code>iter()</code>函数获得一个<code>Iterator</code>对象。</p>
<p>Python的<code>for</code>循环本质上就是通过不断调用<code>next()</code>函数实现的，例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]:</span>
</span></span><span class="line"><span class="cl">    <span class="k">pass</span>
</span></span></code></pre></div><p>实际上完全等价于：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="c1"># 首先获得Iterator对象:</span>
</span></span><span class="line"><span class="cl"><span class="n">it</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="c1"># 循环:</span>
</span></span><span class="line"><span class="cl"><span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 获得下一个值:</span>
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 遇到StopIteration就退出循环</span>
</span></span><span class="line"><span class="cl">        <span class="k">break</span>
</span></span></code></pre></div><h2 id="函数式编程">函数式编程</h2>
<h3 id="高阶函数">高阶函数</h3>
<h4 id="mapreduce">map/reduce</h4>
<p><code>map()</code> 函数包括两个参数，第一个参数是一个函数，第二个参数是一个序列。<strong>map</strong> 的作用就是将序列中的每个元素代入到函数中并且求出每个元素对应的值，然后会返回一个相应的 <code>Iterator </code> ，我们可以通过对应的语句，好比 <code>list()</code> ，<code>tuple()</code> 啥的转成对应的序列。</p>
<p><code>reduce()</code> 函数也是包括两个参数，一个是函数，一个是序列。<strong>reduce</strong> 的作用是类似于一个递归的感觉吧大概，好比序列是 <code>L = [1,2,3,4,5]</code> ，有一个函数是 <code>f</code> ，我们暂且不管这个函数的作用是什么，那么如果我们现在调用 <code>reduce(f,L)</code> ，他返回一个 <code>f</code> 函数的返回值，值为 <code>f(f(f(1,2),3),4)</code> 。就是类似于这种嵌套的结构。</p>
<h4 id="filter">filter</h4>
<p><code>filter()</code> 函数也包括两个参数，一个是函数，一个是序列。他是通过那个函数的返回值是 <code>True</code> or <code>False</code> 来判断是否保留那个序列中的每个元素。返回值也是 <code>Iterator</code> 。</p>
<h4 id="sorted">sorted</h4>
<p><code>sorted()</code> 顾名思义，这是一个排序函数，我们往里面传入一个序列，那么他就会默认的对序列按升序排序，并且返回一个这个排序后序列。<strong>但是我们传入的序列不会有变动。</strong></p>
<p>此外，<code>sorted()</code> 里面还可以加关键词 key 键值来确定规则，好比我们可以加 <code>key=abs</code> 这样就可以将序列中所有的元素按照绝对值从小到大的顺序。我们也可以加 <code>reverse=True</code> 来变成降序排序。</p>
<h3 id="返回函数">返回函数</h3>
<p>我们知道，函数名只是一个指向函数的变量，我们也可以用另一个变量指向这个函数来引用函数，相当于起了一个别名。因此，我们也可以在函数的返回值中返回一个函数，然后将返回值赋值给一个变量，这样就可以通过这个变量来调用返回的函数。</p>
<blockquote>
<p>我们在一个函数中又定义了一个函数，并且，内部函数可以引用外部函数的参数和局部变量，当外部函数返回内部函数时，相关参数和变量都保存在返回的函数中，这种称为“闭包**（Closure）**”的程序结构拥有极大的威力。</p>
</blockquote>
<p>返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。因为这个变量相当于一个静态变量，现在变了，前面相应的结果也会变。</p>
<blockquote>
<p>返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。</p>
</blockquote>
<p>通过  <code>函数.__name__</code>  可以获得函数的真实名字。</p>
<h3 id="匿名函数">匿名函数</h3>
<p>通过 <code>lambda</code> 可以创建匿名函数，这个就类似于matlab里面的那个 <code>@</code> 创建的匿名函数。</p>
<p>格式为： <code>lambda 变量: 返回值</code></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span><span class="p">,</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">11</span><span class="p">))))</span> <span class="c1"># [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]</span>
</span></span></code></pre></div><p>我们也可以把匿名函数当作函数的返回值返回。</p>
<h3 id="装饰器">装饰器</h3>
<p>我们可能想在调用函数之前在前面打印一下函数的运行日志，或者其他的一些内容，其他的操作。</p>
<p>这样我们就可以通过装饰器来实现，装饰器是为了给函数加一些其他的修饰，但是不需要在原本函数的基础上做改变。</p>
<p>本质上，<strong>装饰器(decorator)</strong> 是一个返回函数的高阶函数，一个能打印日志的 <strong>decorator</strong> 可以如下定义：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">log</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span><span class="o">**</span><span class="n">kw</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;call </span><span class="si">%s</span><span class="s2">()&#34;</span> <span class="o">%</span> <span class="n">func</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span><span class="o">**</span><span class="n">kw</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">wrapper</span>
</span></span></code></pre></div><p>调用如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nd">@log</span>
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">now</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">	<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;2020-4-18&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">now</span><span class="p">())</span> <span class="c1"># 输出 call now() 2020-4-18</span>
</span></span></code></pre></div><p>在这里， <code>@log</code> 可以等效为 <code>now = log(now)</code> ，那么我们应该怎么理解呢，首先，在我们调用之前，我们就把这个函数传入这个<code>log</code>函数，然后进入 <code>wrapper</code> 函数，先输出了日志，然后返回了一个 <code>func()</code> 函数，然后结束这个函数的定义，又返回了 <code>wrapper</code> 函数，这样就是将日志和原函数组合在一起了。所以最后一起输出</p>
<h3 id="偏函数">偏函数</h3>
<p>偏函数可以看做一个函数其中某一个参数固定，然后另成一个新函数，这样到时候我们重复调用的时候就会比较方便了。</p>
<blockquote>
<p>当函数的参数个数太多，需要简化时，使用<code>functools.partial</code>可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。</p>
</blockquote>
<p><strong>当用 <code>functools.partial</code> 之前我们需要引入 <code>functools</code> 模块。</strong></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">import</span> <span class="nn">functools</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">int2</span> <span class="o">=</span> <span class="n">functools</span><span class="o">.</span><span class="n">partial</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span><span class="n">base</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="s1">&#39;10110&#39;</span><span class="p">,</span><span class="n">base</span><span class="o">=</span><span class="mi">2</span><span class="p">))</span> <span class="c1"># 以二进制来转化这个字符串，得到22</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">int2</span><span class="p">(</span><span class="s1">&#39;10110&#39;</span><span class="p">))</span> <span class="c1"># 和上述等价</span>
</span></span></code></pre></div><h2 id="模块">模块</h2>
<p>这个就是类似于头文件的感觉，模块里面包含了很多别人已经写好了的函数，你引入之后可以直接拿来用，能够大大提高自己的编程效率。</p>
<p>模块是放在包里的，这样可以避免不同模块之间的冲突，包中可以有很多的模块，并且所有包里都有一个相同名字的模块 ， <code>__init__.py</code> ，这个文件说明这个目录是一个包，里面的其他的内容是模块。</p>
<p>模块命名为 <code>包名.模块名</code> ，这样就有效避免了模块与模块之间的冲突</p>
<blockquote>
<p>模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。</p>
<p>创建自己的模块时，要注意：</p>
<ul>
<li>模块名要遵循Python变量命名规范，不要使用中文、特殊字符；</li>
<li>模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行<code>import abc</code>，若成功则说明系统存在此模块。</li>
</ul>
</blockquote>
<h3 id="使用模块">使用模块</h3>
<p>在使用模块之前只需要  <code>import 模块名</code> ，就可以通过 <strong>模块名.方法</strong> 的方式来调用这个模块里面的方法。</p>
<p>当我们在命令行运行模块文件时，Python解释器把一个特殊变量<code>__name__</code>置为<code>__main__</code>，而如果在其他地方导入模块时，<code>if</code>判断将失败，因此，这种<code>if</code>测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。</p>
<h4 id="封装">封装</h4>
<p>在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过<code>_</code>前缀来实现的。</p>
<p>正常的函数和变量名是公开的（public）。但是外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。</p>
<h3 id="安装第三方模块">安装第三方模块</h3>
<p>我们用包管理工具  <code>pip</code>  来安装第三方模块。</p>
<p>安装一个模块只需要 <code>pip install 库名</code> ，这样就成功安装了一个包了。</p>
<p>此外，我们也可以直接安装 <a href="https://www.anaconda.com/">Anaconda</a> ，这是一个基于Python的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把数十个第三方模块自动安装好了，非常简单易用。</p>
<p>下载地址为 ： <a href="https://www.anaconda.com/download/">Anaconda官网</a></p>
<h3 id="模块搜索路径">模块搜索路径</h3>
<p>当我们加载一个模块时，Python会在指定路径搜索对应的模块文件，如果找不到就会返回错误。</p>
<p>默认情况下，Python解释器会搜索当前目录，所有已安装的内置模块和第三方模块，搜索路径存放在  <code>sys</code> 模块的 <code>path</code> 变量中。我们可以通过 <code>sys.path</code> 来查看。</p>
<p>我们要改动这个目录，往里面添加我们需要的，有两个方法。</p>
<ul>
<li>直接通过 <code>sys.path.append()</code> 添加对应的路径，但是运行结束后会失效。</li>
<li>设置环境变量<code>PYTHONPATH</code>，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径，Python自己本身的搜索路径不受影响。</li>
</ul>
<h2 id="资料补充">资料补充</h2>
<ul>
<li><a href="https://www.liaoxuefeng.com/wiki/1016959663602400">廖雪峰的Python教程</a></li>
<li><a href="https://www.jianshu.com/p/62f155eb6ac5">Anaconda介绍、安装及使用教程</a></li>
</ul>]]></content:encoded>
    </item>
  </channel>
</rss>
