python纯函数 python里面函数

如何用 Python 科学计算中的矩阵替代循环

因为在Mathematica中使用循环确实是低效的。。。。。。

深层次的原因涉及到Mathematica的底层实现所以我不太懂，但是至少从下面几个例子可以看出Mathematica里确实有很多比循环更好的方法

求和

首先举一个最简单的求和例子，求的值。为了测试运行时间取n=10^6

一个刚接触Mathematica的同学多半会这样写

sum = 0;

For[i = 1, i = 10^6, i++,

sum += Sin[N@i]];

(*其中N@i的作用是把整数i转化为浮点数，类似于C里的double*)

sum

为了便于计时用Module封装一下，运行时间是2.13秒，如下图

然后一个有一定Mathematica经验的同学多半会知道同样作为循环的Do速度比For快，于是他可能会这么写

然后一个有一定Mathematica经验的同学多半会知道同样作为循环的Do速度比For快，于是他可能会这么写

sum = 0;

Do[sum += Sin[N@i], {i, 1, 10^6}];

sum

如下图，用时1.37秒，比For快了不少

当然了知道Do速度比For快的同学不太可能不知道Sum函数，所以上面其实是我口胡的，他应该会这么写

Sum[Sin[N@i], {i, 1, 10^6}]

如下图，同样的结果，只用了不到0.06秒

如果这位同学还知道Listable属性并且电脑内存不算太小的话，他也可能会这么写

Tr@Sin[N@Range[10^6]]

如下图，只用了不到0.02秒，速度超过For循环的100倍

当然了这只是一个最简单的例子，而且如果数据量更大的话最后一种方法就不能用了。但是这也足以说明在求和时用循环是低效的，无论是内置的Sum函数还是向量化运算，在效率上都远远高于循环

（这部分模仿了不同程序员如何编写阶乘函数这篇文章，强烈推荐对Mathematica有兴趣的同学去看看）

迭代

接下来举一个迭代的例子，（即Logistic map），取，为了测试运行时间同样取n=10^6

还是先用For循环的做法

x = 0.5;

For[i = 1, i = 10^6, i++,

x = 3.5 x (1 - x);

];

x

如下图，运行时间2.06秒

（Do循环和For类似，篇幅所限这里就不写了，有兴趣的同学可以自行尝试）

（Do循环和For类似，篇幅所限这里就不写了，有兴趣的同学可以自行尝试）

然后看看内置的Nest函数

Nest[3.5 # (1 - #) , 0.5, 10^6]

如下图，用时0.02秒，又是将近两个数量级的效率差异

当然了Nest的使用涉及到纯函数，对于Mathematica初学者来说可能有些难以理解，而且一些比较复杂的迭代不太容易写成Nest的形式，但是在迭代时Nest（还包括Fold）的效率确实要好于循环

当然了Nest的使用涉及到纯函数，对于Mathematica初学者来说可能有些难以理解，而且一些比较复杂的迭代不太容易写成Nest的形式，但是在迭代时Nest（还包括Fold）的效率确实要好于循环

遍历列表

依然举一个简单的例子：求一个列表中偶数的个数。为测试生成10^6个1到10之间的随机整数

list = RandomInteger[{1, 10}, 10^6];

(*生成10^6个随机整数*)

如果用For循环的话代码是这样的

num = 0；

For[i = 1, i = 10^6, i++,

If[EvenQ@list[[i]], num++]

];

num

如下图，用时1.73秒

保留上面的思路，单纯的将For循环改为Scan （相当于没有返回结果的Map），代码如下

num = 0；

Scan[If[EvenQ@#, num++] , list];

num

如下图，用时0.91 秒

（Do循环用时1.00秒左右，篇幅所限就不传图了）

摒弃循环的思路，用其他内置函数写

Count[list, _?EvenQ] // AbsoluteTiming

(*直接用Count数出list中偶数的个数*)

Count[EvenQ /@ list, True] // AbsoluteTiming

(*用Map对list中的每个数判断是否偶数，然后用Count数出结果中True的个数*)

Select[list, EvenQ] // Length // AbsoluteTiming

(*选取list中的所有偶数，然后求结果列表长度*)

Count[EvenQ@list, True] // AbsoluteTiming

(*利用EvenQ的Listable属性直接判断list的每个数是否偶数，然后数出结果中True的个数*)

Sum[Boole[EvenQ@i], {i, list}]

(*对list中的每个元素判断是否偶数，将结果相加*)

结果如下图

这个遍历的例子举得不算特别恰当，但也能说明一些问题了：Mathematica中内置了许多神奇的函数，其中大部分只要使用得当效率都比循环高（而且不是一点半点）。就算非要用循环，也要记得（任何能用Do代替For的时候）

这个遍历的例子举得不算特别恰当，但也能说明一些问题了：Mathematica中内置了许多神奇的函数，其中大部分只要使用得当效率都比循环高（而且不是一点半点）。就算非要用循环，也要记得（任何能用Do代替For的时候）

Do比For快

，（遍历列表时）

Scan比Do快

用向量(矩阵)运算代替循环

这个例子来自如何用 Python 科学计算中的矩阵替代循环？ - Kaiser 的回答，我只是把代码从Python翻译成了Mathematica而已。选这个例子是因为它有比较明确的物理意义，而且效率对比非常明显

代码如下

AbsoluteTiming[

n = 100;

u = unew = SparseArray[{{1, _} - 1}, {n, n}] // N // Normal;

For[k = 1, k = 3000, k++,

For[i = 2, i n, i++,

For[j = 2, j n, j++,

unew[[i, j]] =

0.25 (u[[i + 1, j]] + u[[i - 1, j]] + u[[i, j + 1]] +

u[[i, j - 1]])

]

];

u = unew;

];

u1 = u;

]

(*用三重循环，迭代3000次*)

ArrayPlot[u1, DataReversed - True, ColorFunction - "TemperatureMap"]

(*用ArrayPlot绘图*)

AbsoluteTiming[

n = 100;

u = SparseArray[{{1, _} - 1}, {n, n}] // N // Normal;

Do[

u[[2 ;; -2, 2 ;; -2]] =

0.25 (u[[3 ;; -1, 2 ;; -2]] + u[[1 ;; -3, 2 ;; -2]] +

u[[2 ;; -2, 3 ;; -1]] + u[[2 ;; -2, 1 ;; -3]]),

{k, 1, 3000}];

u2 = u;

]

(*用矩阵运算，迭代3000次*)

ArrayPlot[u2, DataReversed - True, ColorFunction - "TemperatureMap"]

(*用ArrayPlot绘图*)

运行结果For循环用时136秒，矩阵运算用时不足0.5秒，且两者答案完全一样。在算法完全相同的情况下两种写法有着超过200倍的效率差距

（图片太长了这里就不直接显示了，链接放在下面）

===========================我是结尾的分隔线===============================

这个答案其实从一开始就跑题了，还写了这么长的目的就在于希望让大家切实地感受到循环的低效并安利一下Mathematica中其它高效的方法。正如wolray的答案中说的，既然选择了使用Mathematica就应该多利用些MMA独有的美妙函数，毕竟如果只是用循环的话C和Fortran之类的语言效率比MMA不知高到哪里去了。。。。。。

当

然我也不是让大家就不用循环了，毕竟很多时候循环的直观性和易读性带来的便利远远比那点效率重要。只是希望大家在循环之前能稍稍想一下，自己的目的是不是

一定要用循环？可不可以用内置函数代替循环？就像上面的几个例子，将循环换成内置函数程序的简洁性和效率都大幅提高，长此以往相信你一定会爱上MMA的~

题外话——关于用编译提速循环

在

MMA中如果一定要使用循环又对效率有一定要求的话，可以选择使用编译，效率能有极大的提高。比如上面的第4个例子使用Complie编译过后的Do循环

用时只有1.86秒，速度提升了将近100倍。如果电脑中有C编译器的话还可以在Compile中加入CompilationTarget -

"C"选项，速度还能有所提升。编译过后的代码如下：

In[10]:= cf = Compile[{{n, _Integer}, {times, _Integer}},

Module[{u},

u = ConstantArray[0., {n, n}];

u[[1]] = ConstantArray[1., n];

Do[

Do[u[[i, j]] =

0.25 (u[[i + 1, j]] + u[[i - 1, j]] + u[[i, j + 1]] +

u[[i, j - 1]]),

{i, 2, n - 1}, {j, 2, n - 1}

], {k, 1, times}];

u

]

];

u3 = cf[100, 3000]; // AbsoluteTiming

ArrayPlot[u3, DataReversed - True, ColorFunction - "TemperatureMap"]

Out[11]= {1.86055, Null}

前3个例子也都可以通过编译提速很多，这里就不放代码了，有兴趣的同学可以自己动手试一试，如果遇到问题欢迎在评论中与我交流。

需要注意的是编译有很多注意事项，这里推荐一篇写的很好的教程，编译中常见的问题里面都有很好的讲解：怎样编译（Compile）/编译的通用规则/学会这6条，你也会编译

但是一般来讲编译很麻烦，而且再怎么编译效率也很难赶上直接用C，所以个人并不特别建议MMA初学者学习编译。

相关问答

Q1: Python中的类相比与函数有什么异同

优点：可以保存状态

缺点：可以保存状态

解释：

如果不能保存状态，那么每次调用函数时，你都不得不把相关信息通过参数传递过来，麻烦并且在参数多时容易出错。

当一个东西包含状态，意味着很多操作会带有修改其内部状态的副作用。当项目管理不善时，某些对象的内部状态可能多且关系错综复杂，会给维护和调试带来极大的复杂度。也就是稍微改一下，很多东西就出奇怪的问题。

另一方面，将逻辑、算法与状态绑定，会使其不够灵活。比如用着用着，你有多种状态都需要同一种处理逻辑，这时候再把逻辑和算法从类里抽出来就麻烦了。

当然也有纯数据的不可变的类，比如各种 named tuple、datetime 之类的（函数本身就是个类）。函数里也可以通过操作闭包或者全局变量来保存状态。我只是说普通用户所遇到的大部分情况。

推荐策略：举棋不定时听 pylint 的话。

Q2: Python|range函数用法完全解读

迭代器是 23 种设计模式中最常用python纯函数的一种（之一），在 Python 中随处可见它的身影，python纯函数我们经常用到它，但是却不一定意识到它的存在。在关于迭代器的系列文章中（链接见文末），我至少提到了 23 种生成迭代器的方法。有些方法是专门用于生成迭代器的，还有一些方法则是为了解决别的问题而“暗中”使用到迭代器。

在系统学习迭代器之前，我一直以为 range() 方法也是用于生成迭代器的，现在却突然发现，它生成的只是可迭代对象，而并不是迭代器！ （PSpython纯函数：Python2 中 range() 生成的是列表，本文基于Python3，生成的是可迭代对象）

于是，我有了这样的疑问：为什么 range() 不生成迭代器呢？在查找答案的过程中，我发现自己对 range 类型的认识存在一些误区。因此，本文将和大家全面地认识一下 range ，期待与你共同学习进步。

1、range() 是什么？

它的语法：range(start, stop [,step]) python纯函数；start 指的是计数起始值，默认是 0；stop 指的是计数结束值，但不包括 stop ；step 是步长，默认为 1，不可以为 0 。range() 方法生成一段左闭右开的整数范围。

对于 range() 函数，有几个注意点：（1）它表示的是左闭右开区间；（2）它接收的参数必须是整数，可以是负数，但不能是浮点数等其它类型；（3）它是不可变的序列类型，可以进行判断元素、查找元素、切片等操作，但不能修改元素；（4）它是可迭代对象，却不是迭代器。

2、 为什么range()不生产迭代器？

可以获得迭代器的内置方法很多，例如 zip() 、enumerate()、map()、filter() 和 reversed() 等等，但是像 range() 这样仅仅得到的是可迭代对象的方法就绝无仅有了（若有反例，欢迎告知）。这就是我存在知识误区的地方。

在 for-循环 遍历时，可迭代对象与迭代器的性能是一样的，即它们都是惰性求值的，在空间复杂度与时间复杂度上并无差异。我曾概括过两者的差别是“一同两不同”：相同的是都可惰性迭代，不同的是可迭代对象不支持自遍历（即next()方法），而迭代器本身不支持切片（即 getitem () 方法）。

虽然有这些差别，但很难得出结论说它们哪个更优。现在微妙之处就在于，为什么给 5 种内置方法都设计了迭代器，偏偏给 range() 方法设计的就是可迭代对象呢？把它们都统一起来，不是更好么？

事实上，Pyhton 为了规范性就干过不少这种事，例如，Python2 中有 range() 和 xrange() 两种方法，而 Python3 就干掉了其中一种，还用了“李代桃僵”法。为什么不更规范点，令 range() 生成的是迭代器呢？

关于这个问题，我没找到官方解释，以下纯属个人观点 。

zip() 等方法都需要接收确定的可迭代对象的参数，是对它们的一种再加工的过程，因此也希望马上产出确定的结果来，所以 Python 开发者就设计了这个结果是迭代器。这样还有一个好处，即当作为参数的可迭代对象发生变化的时候，作为结果的迭代器因为是消耗型的，不会被错误地使用。

而 range() 方法就不同了，它接收的参数不是可迭代对象，本身是一种初次加工的过程，所以设计它为可迭代对象，既可以直接使用，也可以用于其它再加工用途。例如，zip() 等方法就完全可以接收 range 类型的参数。

也就是说，range() 方法作为一种初级生产者，它生产的原料本身就有很大用途，早早把它变为迭代器的话，无疑是一种画蛇添足的行为。

对于这种解读，你是否觉得有道理呢？欢迎就这个话题与我探讨。

3、range 类型是什么？

以上是我对“为什么range()不产生迭代器”的一种解答。顺着这个思路，我研究了一下它产生的 range 对象，一研究就发现，这个 range 对象也并不简单。

首先奇怪的一点就是，它竟然是不可变序列！我从未注意过这一点。虽然说，我从未想过修改 range() 的值，但这一不可修改的特性还是令我惊讶。

翻看文档，官方是这样明确划分的——有三种基本的序列类型：列表、元组和范围（range）对象。（There are three basic sequence types: lists, tuples, and range objects.）

这我倒一直没注意，原来 range 类型居然跟列表和元组是一样地位的基础序列！我一直记挂着字符串是不可变的序列类型，不曾想，这里还有一位不可变的序列类型呢。

那 range 序列跟其它序列类型有什么差异呢？

普通序列都支持的操作有 12 种。range 序列只支持其中的 10 种，不支持进行加法拼接与乘法重复。

那么问题来了：同样是不可变序列，为什么字符串和元组就支持上述两种操作，而偏偏 range 序列不支持呢？虽然不能直接修改不可变序列，但我们可以将它们拷贝到新的序列上进行操作啊，为何 range 对象连这都不支持呢？

且看官方文档的解释：

…due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern.

原因是 range 对象仅仅表示一个遵循着严格模式的序列，而重复与拼接通常会破坏这种模式…

问题的关键就在于 range 序列的 pattern，仔细想想，其实它表示的就是一个等差数列啊（喵，高中数学知识没忘…），拼接两个等差数列，或者重复拼接一个等差数列，想想确实不妥，这就是为啥 range 类型不支持这两个操作的原因了。由此推论，其它修改动作也会破坏等差数列结构，所以统统不给修改就是了。

4、小结

回顾全文，我得到了两个偏冷门的结论：range 是可迭代对象而不是迭代器；range 对象是不可变的等差序列。

若单纯看结论的话，你也许没有感触，或许还会说这没啥了不得啊。但如果我追问，为什么 range 不是迭代器呢，为什么 range 是不可变序列呢？对这俩问题，你是否还能答出个自圆其说的设计思想呢？（PS：我决定了，若有机会面试别人，我必要问这两个问题的嘿~）

由于 range 对象这细微而有意思的特性，我觉得这篇文章写得值了。本文是作为迭代器系列文章的一篇来写的，所以对于迭代器的基础知识介绍不多，另外，还有一种特殊的迭代器也值得单独成文，那就是生成器了。

Q3: 编程语言分类

机器语言为纯粹的机器代码，机器语言是有0，1，0，1的二进制代码组成，可以由计算机直接执行。汇编语言为8086汇编、Win32汇编、.NET的汇编；高级语言又分为Java、Basic、Pascal、Object Pascal、C、C++、C#、ASP、Perl、PHP、SQL等等（是纯粹的编程语言） 扩展资料

常用编程语言汇总及其用途

C：操作系统、嵌入式、驱动开发

C++：图形图像、科研、通信、桌面软件、游戏、游戏服务器

C#：Windows桌面软件、.NET Web、服务器

Java： Java SE：跨平台的.桌面应用，Android；Java EE：企业级应用，web开发、服务器后端；Java ME：手机应用、流行于非智能机时代；Java Android：用于安卓开发应用

GO：高性能服务器应用，比较年轻

Erlang：高并发服务器应用，多用于游戏

Python：Web、科学计算、运维

Ruby：web

Perl：运维、文本处理，用的较少

Lisp：科研，一种逻辑语言，用于人工智能

Node：一个JavaScript运行环境（runtime）

Haskell：Haskell是一种标准化的、通用纯函数编程语言，数学逻辑方面

Scala：一种类似Java的编程语言，集成面向对象编程和函数式编程的各种特性

Javascript：前端，在node中可以做后端

HTML/CSS：标记语言，主要是给前端工程师构建页面使用

Q4: 如何在python代码中书写纯虚数？

Python是支持虚数的，看下面的例子：

方法一：

# Python3.6

a = 1 + 1j

b = 1 - 1j

print(a*b)

print(a.real, a.imag)

# (2+0j)

# 1.0 1.0

后续的矩阵运算是否可行，要看你的矩阵运算函数是否支持虚数。如果不支持，还需要你自己构造计算虚数的矩阵运算。

方法二（最好使用numpy）：

# Python3.6

import numpy as np

a = np.array([[1+1j, 1-1j], [1-1j, 1+1j]])

print(a*a)

# [[0.+2.j 0.-2.j]

[0.-2.j 0.+2.j]]

print(a.real)

# [[1. 1.]

[1. 1.]]

print(a.imag)

# [[ 1. -1.]

[-1. 1.]]

numpy是支持复数运算的，方便可靠。

关于python纯函数和python里面函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。