北大青鸟设计培训：怎样才能提高Python运行效率？

python逐渐走入人们的视线，成为热门编程语言，随之而来，加入python培训的准程序员大军也成为社会热点。

创新互联公司是一家专业提供铁岭企业网站建设,专注与成都网站设计、成都做网站、外贸网站建设、H5页面制作、小程序制作等业务。10年已为铁岭众多企业、政府机构等服务。创新互联专业网站建设公司优惠进行中。

Python具有许多其他编程语言不具备的优势，譬如能通过极少量代码完成许多操作，以及多进程，能够轻松支持多任务处理。

除了多种优势外，python也有不好的地方，运行较慢，下面电脑培训为大家介绍6个窍门，可以帮你提高python的运行效率。

1.在排序时使用键Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。

最佳的排序方法其实是尽可能多地使用键和内置的sort()方法。

2.交叉编译你的应用开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。

计算机理解的是机器语言。

为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。

有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。

关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。

3.关键代码使用外部功能包Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。

使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。

这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。

简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。

4.针对循环的优化每一种编程语言都强调最优化的循环方案。

当使用Python时，你可以借助丰富的技巧让循环程序跑得更快。

然而，开发者们经常遗忘的一个技巧是：尽量避免在循环中访问变量的属性。

5.尝试多种编码方法每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。

可以在程序分析时尝试一些试验性的办法。

譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。

6.使用较新的Python版本你要保证自己的代码在新版本里还能运行。

你需要使用新的函数库才能体验新的Python版本，然后你需要在做出关键性的改动时检查自己的应用。

只有当你完成必要的修正之后，你才能体会新版本的不同。

Python怎么做最优化

最优化

为什么要做最优化呢？因为在生活中，人们总是希望幸福值或其它达到一个极值，比如做生意时希望成本最小，收入最大，所以在很多商业情境中，都会遇到求极值的情况。

函数求根

这里「函数的根」也称「方程的根」，或「函数的零点」。

先把我们需要的包加载进来。import numpy as npimport scipy as spimport scipy.optimize as optimport matplotlib.pyplot as plt%matplotlib inline

函数求根和最优化的关系？什么时候函数是最小值或最大值？

两个问题一起回答：最优化就是求函数的最小值或最大值，同时也是极值，在求一个函数最小值或最大值时，它所在的位置肯定是导数为 0 的位置，所以要求一个函数的极值，必然要先求导，使其为 0，所以函数求根就是为了得到最大值最小值。

scipy.optimize 有什么方法可以求根？

可以用 scipy.optimize 中的 bisect 或 brentq 求根。f = lambda x: np.cos(x) - x # 定义一个匿名函数x = np.linspace(-5, 5, 1000) # 先生成 1000 个 xy = f(x) # 对应生成 1000 个 f(x)plt.plot(x, y); # 看一下这个函数长什么样子plt.axhline(0, color='k'); # 画一根横线，位置在 y=0

opt.bisect(f, -5, 5) # 求取函数的根0.7390851332155535plt.plot(x, y)plt.axhline(0, color='k')plt.scatter([_], [0], c='r', s=100); # 这里的 [_] 表示上一个 Cell 中的结果，这里是 x 轴上的位置，0 是 y 上的位置

求根有两种方法，除了上面介绍的 bisect，还有 brentq，后者比前者快很多。%timeit opt.bisect(f, -5, 5)%timeit opt.brentq(f, -5, 5)10000 loops, best of 3: 157 s per loopThe slowest run took 11.65 times longer than the fastest. This could mean that an intermediate result is being cached.10000 loops, best of 3: 35.9 s per loop

函数求最小化

求最小值就是一个最优化问题。求最大值时只需对函数做一个转换，比如加一个负号，或者取倒数，就可转成求最小值问题。所以两者是同一问题。

初始值对最优化的影响是什么？

举例来说，先定义个函数。f = lambda x: 1-np.sin(x)/xx = np.linspace(-20., 20., 1000)y = f(x)

当初始值为 3 值，使用 minimize 函数找到最小值。minimize 函数是在新版的 scipy 里，取代了以前的很多最优化函数，是个通用的接口，背后是很多方法在支撑。x0 = 3xmin = opt.minimize(f, x0).x # x0 是起始点，起始点最好离真正的最小值点不要太远plt.plot(x, y)plt.scatter(x0, f(x0), marker='o', s=300); # 起始点画出来，用圆圈表示plt.scatter(xmin, f(xmin), marker='v', s=300); # 最小值点画出来，用三角表示plt.xlim(-20, 20);

初始值为 3 时，成功找到最小值。

现在来看看初始值为 10 时，找到的最小值点。x0 = 10xmin = opt.minimize(f, x0).xplt.plot(x, y)plt.scatter(x0, f(x0), marker='o', s=300)plt.scatter(xmin, f(xmin), marker='v', s=300)plt.xlim(-20, 20);

由上图可见，当初始值为 10 时，函数找到的是局部最小值点，可见 minimize 的默认算法对起始点的依赖性。

那么怎么才能不管初始值在哪个位置，都能找到全局最小值点呢？

如何找到全局最优点？

可以使用 basinhopping 函数找到全局最优点，相关背后算法，可以看帮助文件，有提供论文的索引和出处。

我们设初始值为 10 看是否能找到全局最小值点。x0 = 10from scipy.optimize import basinhoppingxmin = basinhopping(f,x0,stepsize = 5).xplt.plot(x, y);plt.scatter(x0, f(x0), marker='o', s=300);plt.scatter(xmin, f(xmin), marker='v', s=300);plt.xlim(-20, 20);

当起始点在比较远的位置，依然成功找到了全局最小值点。

如何求多元函数最小值？

以二元函数为例，使用 minimize 求对应的最小值。def g(X): x,y = X return (x-1)**4 + 5 * (y-1)**2 - 2*x*yX_opt = opt.minimize(g, (8, 3)).x # (8,3) 是起始点print X_opt[ 1.88292611 1.37658521]fig, ax = plt.subplots(figsize=(6, 4)) # 定义画布和图形x_ = y_ = np.linspace(-1, 4, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, g((X, Y)), 50) # 等高线图ax.plot(X_opt[0], X_opt[1], 'r*', markersize=15) # 最小点的位置是个元组ax.set_xlabel(r"$x_1$", fontsize=18)ax.set_ylabel(r"$x_2$", fontsize=18)plt.colorbar(c, ax=ax) # colorbar 表示颜色越深，高度越高fig.tight_layout()

画3D 图。from mpl_toolkits.mplot3d import Axes3Dfrom matplotlib import cmfig = plt.figure()ax = fig.gca(projection='3d')x_ = y_ = np.linspace(-1, 4, 100)X, Y = np.meshgrid(x_, y_)surf = ax.plot_surface(X, Y, g((X,Y)), rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)cset = ax.contour(X, Y, g((X,Y)), zdir='z',offset=-5, cmap=cm.coolwarm)fig.colorbar(surf, shrink=0.5, aspect=5);

曲线拟合

曲线拟合和最优化有什么关系？

曲线拟合的问题是，给定一组数据，它可能是沿着一条线散布的，这时要找到一条最优的曲线来拟合这些数据，也就是要找到最好的线来代表这些点，这里的最优是指这些点和线之间的距离是最小的，这就是为什么要用最优化问题来解决曲线拟合问题。

举例说明，给一些点，找到一条线，来拟合这些点。

先给定一些点：N = 50 # 点的个数m_true = 2 # 斜率b_true = -1 # 截距dy = 2.0 # 误差np.random.seed(0)xdata = 10 * np.random.random(N) # 50 个 x，服从均匀分布ydata = np.random.normal(b_true + m_true * xdata, dy) # dy 是标准差plt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');

上面的点整体上呈现一个线性关系，要找到一条斜线来代表这些点，这就是经典的一元线性回归。目标就是找到最好的线，使点和线的距离最短。要优化的函数是点和线之间的距离，使其最小。点是确定的，而线是可变的，线是由参数值，斜率和截距决定的，这里就是要通过优化距离找到最优的斜率和截距。

点和线的距离定义如下：def chi2(theta, x, y): return np.sum(((y - theta[0] - theta[1] * x)) ** 2)

上式就是误差平方和。

误差平方和是什么？有什么作用？

误差平方和公式为：

误差平方和大，表示真实的点和预测的线之间距离太远，说明拟合得不好，最好的线，应该是使误差平方和最小，即最优的拟合线，这里是条直线。

误差平方和就是要最小化的目标函数。

找到最优的函数，即斜率和截距。theta_guess = [0, 1] # 初始值theta_best = opt.minimize(chi2, theta_guess, args=(xdata, ydata)).xprint(theta_best)[-1.01442005 1.93854656]

上面两个输出即是预测的直线斜率和截距，我们是根据点来反推直线的斜率和截距，那么真实的斜率和截距是多少呢？-1 和 2，很接近了，差的一点是因为有噪音的引入。xfit = np.linspace(0, 10)yfit = theta_best[0] + theta_best[1] * xfitplt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');plt.plot(xfit, yfit, '-k');

最小二乘（Least Square）是什么？

上面用的是 minimize 方法，这个问题的目标函数是误差平方和，这就又有一个特定的解法，即最小二乘。

最小二乘的思想就是要使得观测点和估计点的距离的平方和达到最小，这里的“二乘”指的是用平方来度量观测点与估计点的远近（在古汉语中“平方”称为“二乘”），“最小”指的是参数的估计值要保证各个观测点与估计点的距离的平方和达到最小。

关于最小二乘估计的计算，涉及更多的数学知识，这里不想详述，其一般的过程是用目标函数对各参数求偏导数，并令其等于 0，得到一个线性方程组。具体推导过程可参考斯坦福机器学习讲义 第 7 页。def deviations(theta, x, y): return (y - theta[0] - theta[1] * x)theta_best, ier = opt.leastsq(deviations, theta_guess, args=(xdata, ydata))print(theta_best)[-1.01442016 1.93854659]

最小二乘 leastsq 的结果跟 minimize 结果一样。注意 leastsq 的第一个参数不再是误差平方和 chi2，而是误差本身 deviations，即没有平方，也没有和。yfit = theta_best[0] + theta_best[1] * xfitplt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');plt.plot(xfit, yfit, '-k');

非线性最小二乘

上面是给一些点，拟合一条直线，拟合一条曲线也是一样的。def f(x, beta0, beta1, beta2): # 首先定义一个非线性函数，有 3 个参数 return beta0 + beta1 * np.exp(-beta2 * x**2)beta = (0.25, 0.75, 0.5) # 先猜 3 个 betaxdata = np.linspace(0, 5, 50)y = f(xdata, *beta)ydata = y + 0.05 * np.random.randn(len(xdata)) # 给 y 加噪音def g(beta): return ydata - f(xdata, *beta) # 真实 y 和 预测值的差，求最优曲线时要用到beta_start = (1, 1, 1)beta_opt, beta_cov = opt.leastsq(g, beta_start)print beta_opt # 求到的 3 个最优的 beta 值[ 0.25525709 0.74270226 0.54966466]

拿估计的 beta_opt 值跟真实的 beta = (0.25, 0.75, 0.5) 值比较，差不多。fig, ax = plt.subplots()ax.scatter(xdata, ydata) # 画点ax.plot(xdata, y, 'r', lw=2) # 真实值的线ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2) # 拟合的线ax.set_xlim(0, 5)ax.set_xlabel(r"$x$", fontsize=18)ax.set_ylabel(r"$f(x, \beta)$", fontsize=18)fig.tight_layout()

除了使用最小二乘，还可以使用曲线拟合的方法，得到的结果是一样的。beta_opt, beta_cov = opt.curve_fit(f, xdata, ydata)print beta_opt[ 0.25525709 0.74270226 0.54966466]

有约束的最小化

有约束的最小化是指，要求函数最小化之外，还要满足约束条件，举例说明。

边界约束def f(X): x, y = X return (x-1)**2 + (y-1)**2 # 这是一个碗状的函数x_opt = opt.minimize(f, (0, 0), method='BFGS').x # 无约束最优化

假设有约束条件，x 和 y 要在一定的范围内，如 x 在 2 到 3 之间，y 在 0 和 2 之间。bnd_x1, bnd_x2 = (2, 3), (0, 2) # 对自变量的约束x_cons_opt = opt.minimize(f, np.array([0, 0]), method='L-BFGS-B', bounds=[bnd_x1, bnd_x2]).x # bounds 矩形约束fig, ax = plt.subplots(figsize=(6, 4))x_ = y_ = np.linspace(-1, 3, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, f((X,Y)), 50)ax.plot(x_opt[0], x_opt[1], 'b*', markersize=15) # 没有约束下的最小值，蓝色五角星ax.plot(x_cons_opt[0], x_cons_opt[1], 'r*', markersize=15) # 有约束下的最小值，红色星星bound_rect = plt.Rectangle((bnd_x1[0], bnd_x2[0]), bnd_x1[1] - bnd_x1[0], bnd_x2[1] - bnd_x2[0], facecolor="grey")ax.add_patch(bound_rect)ax.set_xlabel(r"$x_1$", fontsize=18)ax.set_ylabel(r"$x_2$", fontsize=18)plt.colorbar(c, ax=ax)fig.tight_layout()

不等式约束

介绍下相关理论，先来看下存在等式约束的极值问题求法，比如下面的优化问题。

目标函数是 f(w)，下面是等式约束，通常解法是引入拉格朗日算子，这里使用 ββ 来表示算子，得到拉格朗日公式为

l 是等式约束的个数。

然后分别对 w 和ββ 求偏导，使得偏导数等于 0，然后解出 w 和βiβi，至于为什么引入拉格朗日算子可以求出极值，原因是 f(w) 的 dw 变化方向受其他不等式的约束，dw的变化方向与f(w)的梯度垂直时才能获得极值，而且在极值处，f(w) 的梯度与其他等式梯度的线性组合平行，因此他们之间存在线性关系。（参考《最优化与KKT条件》）

对于不等式约束的极值问题

常常利用拉格朗日对偶性将原始问题转换为对偶问题，通过解对偶问题而得到原始问题的解。该方法应用在许多统计学习方法中。有兴趣的可以参阅相关资料，这里不再赘述。def f(X): return (X[0] - 1)**2 + (X[1] - 1)**2def g(X): return X[1] - 1.75 - (X[0] - 0.75)**4x_opt = opt.minimize(f, (0, 0), method='BFGS').xconstraints = [dict(type='ineq', fun=g)] # 约束采用字典定义，约束方式为不等式约束，边界用 g 表示x_cons_opt = opt.minimize(f, (0, 0), method='SLSQP', constraints=constraints).xfig, ax = plt.subplots(figsize=(6, 4))x_ = y_ = np.linspace(-1, 3, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, f((X, Y)), 50)ax.plot(x_opt[0], x_opt[1], 'b*', markersize=15) # 蓝色星星，没有约束下的最小值ax.plot(x_, 1.75 + (x_-0.75)**4, '', markersize=15)ax.fill_between(x_, 1.75 + (x_-0.75)**4, 3, color="grey")ax.plot(x_cons_opt[0], x_cons_opt[1], 'r*', markersize=15) # 在区域约束下的最小值ax.set_ylim(-1, 3)ax.set_xlabel(r"$x_0$", fontsize=18)ax.set_ylabel(r"$x_1$", fontsize=18)plt.colorbar(c, ax=ax)fig.tight_layout()

scipy.optimize.minimize 中包括了多种最优化算法，每种算法使用范围不同，详细参考官方文档。

如何提高python的运行效率

窍门一：关键代码使用外部功能包

Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。以下是一些你可以选择用来提升效率的功能包：

Cython

Pylnlne

PyPy

Pyrex

这些功能包的用处各有不同。比如说，使用C语言的数据类型，可以使涉及内存操作的任务更高效或者更直观。Pyrex就能帮助Python延展出这样的功能。Pylnline能使你在Python应用中直接使用C代码。内联代码是独立编译的，但是它把所有编译文件都保存在某处，并能充分利用C语言提供的高效率。

窍门二：在排序时使用键

Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。最佳的排序方法其实是尽可能多地使用键和内置的sort()方法。譬如，拿下面的代码来说：

import operator

somelist = [(1, 5, , (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(0))

somelist

#Output = [(1, 5, , (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(1))

somelist

#Output = [(6, 2, 4), (1, 5, , (9, 7, 5)]

somelist.sort(key=operator.itemgetter(2))

somelist

#Output = [(6, 2, 4), (9, 7, 5), (1, 5, ]

在每段例子里，list都是根据你选择的用作关键参数的索引进行排序的。这个方法不仅对数值类型有效，还同样适用于字符串类型。

窍门三：针对循环的优化

每一种编程语言都强调最优化的循环方案。当使用Python时，你可以借助丰富的技巧让循环程序跑得更快。然而，开发者们经常遗忘的一个技巧是：尽量避免在循环中访问变量的属性。譬如，拿下面的代码来说：

lowerlist = ['this', 'is', 'lowercase']

upper = str.upper

upperlist = []

append = upperlist.append

for word in lowerlist:

append(upper(word))

print(upperlist)

#Output = ['THIS', 'IS', 'LOWERCASE']

每次你调用str.upper, Python都会计算这个式子的值。然而，如果你把这个求值赋值给一个变量，那么求值的结果就能提前知道，Python程序就能运行得更快。因此，关键就是尽可能减小Python在循环中的工作量。因为Python解释执行的特性，在上面的例子中会大大减慢它的速度。

（注意：优化循环的方法还有很多，这只是其中之一。比如，很多程序员会认为，列表推导式是提高循环速度的最佳方法。关键在于，优化循环方案是提高应用程序运行速度的上佳选择。）

窍门四：使用较新的Python版本

如果你在网上搜索Python，你会发现数不尽的信息都是关于如何升级Python版本。通常，每个版本的Python都会包含优化内容，使其运行速度优于之前的版本。但是，限制因素在于，你最喜欢的函数库有没有同步更新支持新的Python版本。与其争论函数库是否应该更新，关键在于新的Python版本是否足够高效来支持这一更新。

你要保证自己的代码在新版本里还能运行。你需要使用新的函数库才能体验新的Python版本，然后你需要在做出关键性的改动时检查自己的应用。只有当你完成必要的修正之后，你才能体会新版本的不同。

然而，如果你只是确保自己的应用在新版本中可以运行，你很可能会错过新版本提供的新特性。一旦你决定更新，请分析你的应用在新版本下的表现，并检查可能出问题的部分，然后优先针对这些部分应用新版本的特性。只有这样，用户才能在更新之初就觉察到应用性能的改观。

窍门五：尝试多种编码方法

每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。可以在程序分析时尝试一些试验性的办法。譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。请看下面第一段代码：

n = 16

myDict = {}

for i in range(0, n):

char = 'abcd'[i%4]

if char not in myDict:

myDict[char] = 0

myDict[char] += 1

print(myDict)

当一开始myDict为空时，这段代码会跑得比较快。然而，通常情况下，myDict填满了数据，至少填有大部分数据，这时换另一种方法会更有效率。

n = 16

myDict = {}

for i in range(0, n):

char = 'abcd'[i%4]

try:

myDict[char] += 1

except KeyError:

myDict[char] = 1

print(myDict)

在两种方法中输出结果都是一样的。区别在于输出是如何获得的。跳出常规的思维模式，创建新的编程技巧能使你的应用更有效率。

窍门六：交叉编译你的应用

开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。计算机理解的是机器语言。为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。

Nuitka是一款有趣的交叉编译器，能将你的Python代码转化成C++代码。这样，你就可以在native模式下执行自己的应用，而无需依赖于解释器程序。你会发现自己的应用运行效率有了较大的提高，但是这会因平台和任务的差异而有所不同。

（注意：Nuitka现在还处在测试阶段，所以在实际应用中请多加注意。实际上，当下最好还是把它用于实验。此外，关于交叉编译是否为提高运行效率的最佳方法还存在讨论的空间。开发者已经使用交叉编译多年，用来提高应用的速度。记住，每一种解决办法都有利有弊，在把它用于生产环境之前请仔细权衡。）

在使用交叉编译器时，记得确保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。为了让解决方案生效，你需要一个Python解释器和一个C++编译器。Nuitka支持许多C++编译器，其中包括Microsoft Visual Studio,MinGW 和 Clang/LLVM。

交叉编译可能造成一些严重问题。比如，在使用Nuitka时，你会发现即便是一个小程序也会消耗巨大的驱动空间。因为Nuitka借助一系列的动态链接库（DDLs）来执行Python的功能。因此，如果你用的是一个资源很有限的系统，这种方法或许不太可行。

#Python干货#python实现——最优化算法

函数详见rres，此代码使该算法运行了两次

收获：

这是我第一个实现的代码。学习完该算法以后，逻辑框架基本上就有了，剩下需要明确的就是对应的python的语言。于是我就开始了查找“如何定义函数”（详见mofan的优酷），“循环体”和“if条件语句”的格式（）“数学符号”（详见mofan的优酷），以及print的使用

1.def是python中指定义，一般用来定义函数，如果需要深度学习搭建网络可用来定义网络。值得注意的一点是

我不清楚为什么，但是如果没有加的话，那个函数公式就是一个花瓶，就像一个结果输不出去。

2.最坑的就是逻辑。一开始逻辑没理清楚，或者说在代码上有疏漏，导致我将left和right放在了循环体里，结果可想而知。不过也是因为这个错误，我知道pycharm中的debug怎么用，挺简单的，百度一下就出来了。

3.不知道什么原因，看的莫烦视频中的print多个变量一起输出是没有办法在我的pycharm中使用的，出来的结果很奇怪。可能是因为我是win10不是ios吧。print如果多个变量一起输出必须是print("名字：%s,名字2：%s"%(a,b))结果输出就是名字：a ,名字2：b

关于python中数据变量。第一遍运行结果出现很明显不对，于是我采用了debug。结果发现，mid1处一直为1而不是1.5，于是就开始了解数据变量。起初我猜测python默认所有变量为整型，但是根据二分法的结果我意识到此猜测不对，所以要改整个file的变量格式没有必要。所以我就在mid1式子前面加了一个float，结果就显示为1.5了。但是如果我将整个式子用（）括起来，前面加float，结果还是1。我不太理解为什么。不过我知道了python的数据格式是根据输入量决定的，也就是说你的输入量如果是整型，那么与其直接相关的计算输出结果一定是整型，而且还是不采用进位的整型。在我没有采用+float/+.0这两种方法之前，mid1~3全部是整型。

或者不再mid1前面加float,直接将输入量后面点个点就行

真的很想吐槽一下print,好麻烦啊啊啊啊每次都得弄个%s,而且有时候还不能放一起！！！！

不要问我掌握了什么，要问我现在写完这个代码后有多么的爱python的精度表示 :-)我决定以后只要再编写数学公式的代码都将输入量的小数学点后面补很多0

fibonacci函数定义，每次debug后我的手都是抖的O( _ )O~

不知道自己什么时候有的强迫症，只要是代码下面有“~”我就必须要消掉。笑哭。这个很简单，前四个除了费波纳茨，都很简单。

这个公式看起来很麻烦，便写的时候更要谨慎。我上回把那个2搁在了分号下面，结果很大，所以还是换算成0.5更好（PS：勿忘那长河般的0）。

虽然代码很长，但是主要是因为print太多。本打算在开头print，最后结果会漏掉最后一部分。懒得想其他办法了，直接就这样吧

一开始while里面写成了,导致run不出来。继而，debug也没法用。在网上一查才知道 “没联网”+“没选断点”。最后想尝试将else里面的内容输出来，结果发现run以后被刷屏了。于是改成i7以后还是不行，于是想着加一个break跳出循环，结果成效了。

然后刚刚由debug了一下，才知道原来是i+1在if里面，因为没有办法+1，所以i=6一直存在，就不断循环。因为加break也好，i+1也好，都可以。

这是我第一组自己实现的python代码，就是数学公式用python语言组装起来。刚开始的时候知道大概需要在语言中体现什么，但不太清楚。于是我就在网上找了几个二分法的，他们都各有不同，但框架都差不多，不过如果要用到我们的那个公式里还需要改变很多。然后我就开始分析我们的题，我发现大体需要两部分，一部分函数定义，一部分循环体。但我不知道如何定义函数，如何写数学公式，如何弄变量，也就是说一些小点不太会，所以我选择直接百度。因为我知道自己阅读的能力不错，相比于从视频中提取要素，我更擅长通过阅读获得要点。有目的性地找知识点，掌握地更牢固。

于是我就开始了第一个——二分法的编写。我发现，自己出现了很多错误而且有很多地方都很基础。但我依然没选择视频，而是将这些问题直接在百度上找，因为视频讲完或许你也没找到点。当然，这是一步一步走的，不是直接就将程序摆上去，一点一点改。

随着前两个的成功，我发现自己对于这些代码有了自信，似乎看透了他们的伪装，抓住了本质。除此之外，我还意识到自己自从8月份以后，学习能力似乎提高了不少，而且有了更为有效的学习方法。各方面都有了一定的觉醒。除了第一个找了几个牛头不对马嘴的代码，其他都是根据自己的逻辑写，逻辑通下来以后，对应语言中某一部分不知道如何翻译就去百度，其实这几个套路都一样或者说数学公式转化的套路都一样。

我还意识到，汇编其实是最难的语言，目前为止所学到的，因为很多都需要自己去定义，去死抠，需要记住大量的指令且不能灵活变通。但是其他的却只需要将一些对应的记下来就好。python真的挺简单的。而且，我发现自己今天似乎打开了新世界的大门，我爱上了这种充满了灵性的东西，充满了严谨的美丽，还有那未知的变化，我发现我似乎爱上了代码。可能不仅仅局限于python，这些语言都充满了挑战性。我觉得当你疑惑的时候，就需要相信直觉，至少我发现它很准

文章名称：python函数最优化 python性能优化
文章转载：http://scyingshan.cn/article/dooeosc.html