没有公司做网站可以吗,山东经济建设网站,网络营销推广的常用方法有哪些,网站外链有什么用Python函数式编程是一种编程范式#xff0c;它强调使用纯函数来处理数据。函数是程序的基本构建块#xff0c;并且尽可能避免或最小化可变状态和副作用。在函数式编程中#xff0c;函数被视为一等公民#xff0c;可以像值一样传递和存储。
函数式编程概念
编程语言支持通…Python函数式编程是一种编程范式它强调使用纯函数来处理数据。函数是程序的基本构建块并且尽可能避免或最小化可变状态和副作用。在函数式编程中函数被视为一等公民可以像值一样传递和存储。
函数式编程概念
编程语言支持通过以下几种方式来解构具体问题
大多数的编程语言都是 过程式 的所谓程序就是一连串告诉计算机怎样处理程序输入的指令。C、Pascal 甚至 Unix shells 都是过程式语言。在 声明式 语言中你编写一个用来描述待解决问题的说明并且这个语言的具体实现会指明怎样高效的进行计算。 SQL 可能是你最熟悉的声明式语言了。 一个 SQL 查询语句描述了你想要检索的数据集并且 SQL 引擎会决定是扫描整张表还是使用索引应该先执行哪些子句等等。面向对象 程序会操作一组对象。 对象拥有内部状态并能够以某种方式支持请求和修改这个内部状态的方法。Smalltalk 和 Java 都是面向对象的语言。 C 和 Python 支持面向对象编程但并不强制使用面向对象特性。函数式 编程则将一个问题分解成一系列函数。 理想情况下函数只接受输入并输出结果对一个给定的输入也不会有影响输出的内部状态。 著名的函数式语言有 ML 家族Standard MLOcaml 以及其他变种和 Haskell。
一些语言的设计者选择强调一种特定的编程方式。 这通常会让以不同的方式来编写程序变得困难。其他多范式语言则支持几种不同的编程方式。LispC 和 Python 都是多范式语言使用这些语言你可以编写主要为过程式面向对象或者函数式的程序和函数库。在大型程序中不同的部分可能会采用不同的方式编写比如 GUI 可能是面向对象的而处理逻辑则是过程式或者函数式。
在函数式程序里输入会流经一系列函数。每个函数接受输入并输出结果。函数式风格反对使用带有副作用的函数这些副作用会修改内部状态或者引起一些无法体现在函数的返回值中的变化。完全不产生副作用的函数被称作“纯函数”。消除副作用意味着不能使用随程序运行而更新的数据结构每个函数的输出必须只依赖于输入。 一些语言对纯洁性要求非常严格以至于没有像 a3 或 c a b 这样的赋值表达式但是完全消除副作用非常困难。 比如显示在屏幕上或者写到磁盘文件中都是副作用。举个例子在 Python 里调用函数 print() 或者 time.sleep() 并不会返回有用的结果它们的用途只在于副作用向屏幕发送一段文字或暂停一秒钟。 函数式风格的 Python 程序并不会极端到消除所有 I/O 或者赋值的程度相反他们会提供像函数式一样的接口但会在内部使用非函数式的特性。比如函数的实现仍然会使用局部变量但不会修改全局变量或者有其他副作用。 函数式编程可以被认为是面向对象编程的对立面。对象就像是颗小胶囊包裹着内部状态和随之而来的能让你修改这个内部状态的一组调用方法以及由正确的状态变化所构成的程序。函数式编程希望尽可能地消除状态变化只和流经函数的数据打交道。在 Python 里你可以把两种编程方式结合起来在你的应用电子邮件信息事务处理中编写接受和返回对象实例的函数。
函数式设计在工作中看起来是个奇怪的约束。为什么你要消除对象和副作用呢不过函数式风格有其理论和实践上的优点
形式证明。模块化。组合性。易于调试和测试。
形式证明
一个理论上的优点是构造数学证明来说明函数式程序是正确的相对更容易些。
很长时间研究者们对寻找证明程序正确的数学方法都很感兴趣。这和通过大量输入来测试并得出程序的输出基本正确或者阅读一个程序的源代码然后得出代码看起来没问题不同相反这里的目标是一个严格的证明证明程序对所有可能的输入都能给出正确的结果。
证明程序正确性所用到的技术是写出 不变量也就是对于输入数据和程序中的变量永远为真的特性。然后对每行代码你说明这行代码执行前的不变量 X 和 Y 以及执行后稍有不同的不变量 X’ 和 Y’ 为真。如此一直到程序结束这时候在程序的输出上不变量应该会与期望的状态一致。
函数式编程之所以要消除赋值是因为赋值在这个技术中难以处理赋值可能会破坏赋值前为真的不变量却并不产生任何可以传递下去的新的不变量。
不幸的是证明程序的正确性很大程度上是经验性质的而且和 Python 软件无关。即使是微不足道的程序都需要几页长的证明一个中等复杂的程序的正确性证明会非常庞大而且极少甚至没有你日常所使用的程序Python 解释器XML 解析器浏览器的正确性能够被证明。即使你写出或者生成一个证明验证证明也会是一个问题里面可能出了差错而你错误地相信你证明了程序的正确性。
模块化
函数式编程的一个更实用的优点是它强制你把问题分解成小的方面。因此程序会更加模块化。相对于一个进行了复杂变换的大型函数一个小的函数更明确更易于编写, 也更易于阅读和检查错误。
易于调试和测试
测试和调试函数式程序相对来说更容易。
调试很简单是因为函数通常都很小而且清晰明确。当程序无法工作的时候每个函数都是一个可以检查数据是否正确的接入点。你可以通过查看中间输入和输出迅速找到出错的函数。
测试更容易是因为每个函数都是单元测试的潜在目标。在执行测试前函数并不依赖于需要重现的系统状态相反你只需要给出正确的输入然后检查输出是否和期望的结果一致。
组合性
当你编写函数式风格的程序时你会写出很多带有不同输入和输出的函数。其中一些不可避免地会局限于特定的应用但其他的却可以广泛的用在程序中。举例来说一个接受文件夹目录返回所有文件夹中的 XML 文件的函数 或是一个接受文件名然后返回文件内容的函数都可以应用在很多不同的场合。
久而久之你会形成一个个人工具库。通常你可以重新组织已有的函数来组成新的程序然后为当前的工作写一些特殊的函数。
迭代器
迭代器是Python函数式编程的基础前面我们对迭代器进行了反复的学习回顾迭代器的核心知识
迭代器是一个表示数据流的对象这个对象每次只返回一个元素。迭代器必须支持 __next__() 方法这个方法不接受参数并总是返回数据流中的下一个元素。如果数据流中没有元素__next__() 会抛出 StopIteration 异常。迭代器未必是有限的完全有理由构造一个输出无限数据流的迭代器。内置的 iter() 函数接受任意对象并试图返回一个迭代器来输出对象的内容或元素并会在对象不支持迭代的时候抛出 TypeError 异常。Python 有几种内置数据类型支持迭代最常见的就是列表和字典。如果一个对象能生成迭代器那么它就会被称作 iterable。Python中有很多场景使用迭代器其中最常见的是在for表达式中像max()、min()以及前面学到的一些高级函数都是支持迭代器的。
注意你只能在迭代器中顺序前进没有获取前一个元素的方法除非重置迭代器或者重新复制一份。迭代器对象可以提供这些额外的功能但迭代器协议只明确了 __next__() 方法。函数可能因此而耗尽迭代器的输出如果你要对同样的数据流做不同的操作你必须重新创建一个迭代器。
我们已经知道列表、元组、字符串、字典等类型都支持迭代器也可以自定义类实现__iter__()方法和__next__()方法来实现自己的迭代器。
迭代器还支持生成器表达式和列表推导式这些让操作显得更简单明了。
列表推导式
[ expression for expr in sequence1if condition1for expr2 in sequence2if condition2for expr3 in sequence3 ...if condition3for exprN in sequenceNif conditionN ]
等价于
for expr1 in sequence1:if not (condition1):continue # Skip this elementfor expr2 in sequence2:if not (condition2):continue # Skip this element...for exprN in sequenceN:if not (conditionN):continue # Skip this element# Output the value of# the expression.
生成器表达式只需要把上面的[]替换为()即可。
高阶函数map()、reduce()、filter()等实际就是函数式编程的方式在运转。为了支持更多的函数式编程itertools模块支持更多的常用的迭代器以及用来组合迭代器的函数。
itertools 模块
本模块实现一系列 iterator 这些迭代器受到函数式编程语言APL、Haskell和SML等的启发。为了适用于Python它们都被重新写过。
本模块标准化了一个快速、高效利用内存的核心工具集这些工具本身或组合都很有用。它们一起形成了“迭代器代数”这使得在纯Python中有可能创建简洁又高效的专用工具。
例如SML有一个制表工具 tabulate(f)它可产生一个序列 f(0), f(1), ...。在Python中可以组合 map() 和 count() 实现 map(f, count())。
这些工具也能提供良好的性能也能与operator模块的功能进行集成。
迭代器
itertools除使用原有的一般迭代器外还提供了许多扩展的迭代器。
无穷迭代器
序号迭代器
itertools.count(start0, step1)
创建一个迭代器它从 start 值开始返回均匀间隔的值。常用于 map() 中的实参来生成连续的数据点。此外还用于 zip() 来添加序列号。
参数说明
start起始值step间隔值
大致相当于
def count(start0, step1):# count(10) -- 10 11 12 13 14 ...# count(2.5, 0.5) -- 2.5 3.0 3.5 ...n startwhile True:yield nn step
当对浮点数计数时替换为乘法代码有时精度会更好例如 (start step * i for i in count()) 。
import itertoolsFruits [pear, peach, apple, grape, banana, cherry, strawberry, watermelon]fruitList list(zip(itertools.count(start1), Fruits))
print(fruitList)‘’
[(1, pear), (2, peach), (3, apple), (4, grape), (5, banana), (6, cherry), (7, strawberry), (8, watermelon)]
‘
循环迭代器
itertools.cycle(iterable)
创建一个迭代器返回 iterable 中所有元素并保存一个副本。当取完 iterable 中所有元素返回副本中的所有元素。无限重复。大致相当于
def cycle(iterable):# cycle(ABCD) -- A B C D A B C D A B C D ...saved []for element in iterable:yield elementsaved.append(element)while saved:for element in saved:yield element
import itertools
import datetimeDays [星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日]BaseDate datetime.date(2023, 9, 4)
datelist [BaseDate datetime.timedelta(daysd) for d in range(10)]
print(datelist)
daylist list(zip(datelist, itertools.cycle(Days)))
print(daylist)‘’
[datetime.date(2023, 9, 4), datetime.date(2023, 9, 5), datetime.date(2023, 9, 6), datetime.date(2023, 9, 7), datetime.date(2023, 9, 8), datetime.date(2023, 9, 9), datetime.date(2023, 9, 10), datetime.date(2023, 9, 11), datetime.date(2023, 9, 12), datetime.date(2023, 9, 13)]
[(datetime.date(2023, 9, 4), 星期一), (datetime.date(2023, 9, 5), 星期二), (datetime.date(2023, 9, 6), 星期三), (datetime.date(2023, 9, 7), 星期四), (datetime.date(2023, 9, 8), 星期五), (datetime.date(2023, 9, 9), 星期六), (datetime.date(2023, 9, 10), 星期日), (datetime.date(2023, 9, 11), 星期一), (datetime.date(2023, 9, 12), 星期二), (datetime.date(2023, 9, 13), 星期三)]
‘
重复迭代器
itertools.repeat(object[, times])
重复的提供times个object如果不设置times则提供无限个。
import itertoolsfor it in itertools.repeat(fruits, times3):print(it)’’’
fruits
fruits
fruits
‘’‘ 短序列迭代器
根据最短输入序列长度停止的迭代器
累积迭代器
itertools.accumulate(iterable[, func, *, initialNone])
创建一个迭代器返回累积汇总值或其他双目运算函数的累积结果值通过可选的 func 参数指定。
例如一个序列为[1,2,3,4,5]
迭代器的第1个值等于序列的第1个值为1迭代器的第2个值为迭代器的第1个值加上序列的第2个值12为3迭代器的第3个值为迭代器的第2个值加上序列的第3个值33为6依次类推
import itertoolsnums [1,2,3,4,5]
anums [it for it in itertools.accumulate(nums)]
print(anums)‘’
[1, 3, 6, 10, 15]
‘
如果提供了 func它应当为带有两个参数的函数。 输入 iterable 的元素可以是能被 func 接受为参数的任意类型。 例如对于默认的加法运算元素可以是任何可相加的类型包括 Decimal 或 Fraction。
例如我们改为连乘
import itertoolsnums [1,2,3,4,5]
anums [it for it in itertools.accumulate(nums, funclambda a,b:a*b)]
print(anums)‘’
[1, 2, 6, 24, 120]
‘
通常输出的元素数量与输入的可迭代对象是一致的。 但是如果提供了关键字参数 initial则累加会以 initial 值开始这样输出就比输入的可迭代对象多一个元素。
序列连接迭代器
itertools.chain(*iterables)
创建一个迭代器它首先返回第一个可迭代对象中所有元素接着返回下一个可迭代对象中所有元素直到耗尽所有可迭代对象中的元素。可将多个序列处理为单个序列。
import itertoolsfruits [mango, pear, peach]
nums [1,2,3,4,5]anums list(itertools.chain(fruits, nums))
print(anums)‘’
[mango, pear, peach, 1, 2, 3, 4, 5]
‘
展开迭代器
classmethod chain.from_iterable(iterable)
可以把一个嵌套的list展开成一维的迭代器。
import itertoolsfruits [mango, pear, peach]
nums [1,2,3,4,5]anums list(itertools.chain.from_iterable([fruits, nums, ABCDE]))
print(anums)alist [[mango, pear, peach], [grape, banana, cherry], ([a, b, c], (n, l, 1)), {k1:v1, k2:v2}]
nlist list(itertools.chain.from_iterable(alist))
print(nlist)blist list(itertools.chain(alist))
print(blist)‘’
[mango, pear, peach, 1, 2, 3, 4, 5, A, B, C, D, E]
[mango, pear, peach, grape, banana, cherry, [a, b, c], (n, l, 1), k1, k2]
[[mango, pear, peach], [grape, banana, cherry], ([a, b, c], (n, l, 1)), {k1: v1, k2: v2}]‘
从上面的例子可以看到只做一次的展开不会深入。
简单过滤迭代器
itertools.compress(data, selectors)
创建一个迭代器它返回 data iterable对象中经 selectorsiterable对象 真值测试为 True 的元素。迭代器在两者较短的长度处停止。
print(list(itertools.compress([mango, pear, peach, grape, banana], [1,0,0,1])))
#[mango, grape] 跳过开头迭代器
itertools.dropwhile(predicate, iterable)
predicate是一个函数对象接受一个参数即iterable的元素。
创建一个迭代器如果前面元素的 predicate 连续为True迭代器丢弃这些元素如果出现第一个False的元素就开始返回后面的元素不再检查那些元素的predicate是否为真。注意迭代器在 predicate 首次为false之前不会产生任何输出直接跳过所以可能需要一定长度的启动时间。大致相当于
def dropwhile(predicate, iterable):# dropwhile(lambda x: x5, [1,4,6,4,1]) -- 6 4 1iterable iter(iterable)for x in iterable:if not predicate(x):yield xbreakfor x in iterable:yield x
例子
import itertools
import datetimeDays [星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日]BaseDate datetime.date(2023, 9, 1)def checkMonday(d:datetime.date):print(f{d}, {d.weekday()})if d.weekday() 0:return Falseelse:return Truedatelist [BaseDate datetime.timedelta(daysd) for d in range(14)]
print(datelist)
daylist list(zip(Days, itertools.dropwhile(checkMonday,datelist)))
print(daylist)‘’’
[datetime.date(2023, 9, 1), datetime.date(2023, 9, 2), datetime.date(2023, 9, 3), datetime.date(2023, 9, 4), datetime.date(2023, 9, 5), datetime.date(2023, 9, 6), datetime.date(2023, 9, 7), datetime.date(2023, 9, 8), datetime.date(2023, 9, 9), datetime.date(2023, 9, 10), datetime.date(2023, 9, 11), datetime.date(2023, 9, 12), datetime.date(2023, 9, 13), datetime.date(2023, 9, 14)]
2023-09-01, 4
2023-09-02, 5
2023-09-03, 6
2023-09-04, 0
[(星期一, datetime.date(2023, 9, 4)), (星期二, datetime.date(2023, 9, 5)), (星期三, datetime.date(2023, 9, 6)), (星期四, datetime.date(2023, 9, 7)), (星期五, datetime.date(2023, 9, 8)), (星期六, datetime.date(2023, 9, 9)), (星期日, datetime.date(2023, 9, 10))]
’‘’
跳过尾部迭代器
itertools.takewhile(predicate, iterable)
创建一个迭代器只要前面的元素的 predicate 连续为真就从可迭代对象中返回元素只要有一个元素的predicate为False就立即终止不再检查后面的元素的predicate
predicate是一个函数对象接受一个参数即iterable的元素。
alist list(itertools.takewhile(lambda x:x10, [1,3,5,6,7,11,3,2,1]))
print(alist) #[1, 3, 5, 6, 7]tee迭代器
itertools.tee(iterable, n2)
从一个可迭代对象中返回 n 个独立的迭代器。
例如将[1,2,3,4,5]变成[[1,2,3,4,5],[1,2,3,4,5]]
its itertools.tee([1,2,3,4,5,6,7], 3)
for it in its:print(list(it))‘’
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7]
‘
zip补齐迭代器
itertools.zip_longest(*iterables, fillvalueNone)
zip会按最短的迭代对象压缩迭代器zip_longest()按最长的进行压缩如果一个迭代器长度不够使用fillvalue进行填充。
alist [1,2,3,4,5,6,7,8]
blist [mango, pear, peach, grape, banana, cherry,apricot, persimmon,medlar, watermelon, apple, pomegranate, currant, blackberry, avocado]zip1 zip(alist, blist)
print(list(zip1))
#[(1, mango), (2, pear), (3, peach), (4, grape), (5, banana), (6, cherry), (7, apricot), (8, persimmon)]zip2 itertools.zip_longest(alist, blist, fillvalue0)
print(list(zip2))
#[(1, mango), (2, pear), (3, peach), (4, grape), (5, banana), (6, cherry), (7, apricot), (8, persimmon), (0, medlar), (0, watermelon), (0, apple), (0, pomegranate), (0, currant), (0, blackberry), (0, avocado)] 否定过滤迭代器
itertools.filterfalse(predicate, iterable)
创建一个迭代器如果 predicate 为True迭代器丢弃这些元素返回后面为False的元素如果predicate未None直接对元素的真假进行判断大致相当于
def filterfalse(predicate, iterable):# filterfalse(lambda x: x%2, range(10)) -- 0 2 4 6 8if predicate is None:predicate boolfor x in iterable:if not predicate(x):yield x
例子
import itertools#奇数的无限序列
odd itertools.filterfalse(lambda x:x%2 0, itertools.count(start1))
for num in odd:print(num)if num 11:break‘’’
1
3
5
7
9
11
’‘’ 分组迭代器
itertools.groupby(iterable, keyNone)
创建一个迭代器返回 iterable 中连续的键和组。key 是一个计算元素键值函数。如果未指定或为 Nonekey 缺省为恒等函数identity function返回元素不变。一般来说iterable 需用同一个键值函数预先排序。
groupby() 操作类似于Unix中的 uniq。当每次 key 函数产生的键值改变时迭代器会分组或生成一个新组这就是为什么通常需要使用同一个键值函数先对数据进行排序。这种行为与SQL的GROUP BY操作不同SQL的操作会忽略输入的顺序将相同键值的元素分在同组中。
返回的组本身也是一个迭代器它与 groupby() 共享底层的可迭代对象。因为源是共享的当 groupby() 对象向后迭代时前一个组将消失。因此如果稍后还需要返回结果可保存为列表
groups []
uniquekeys []
data sorted(data, keykeyfunc)
for k, g in groupby(data, keyfunc):groups.append(list(g)) # Store group iterator as a listuniquekeys.append(k)
大致相当于
class groupby:# [k for k, g in groupby(AAAABBBCCDAABBB)] -- A B C D A B# [list(g) for k, g in groupby(AAAABBBCCD)] -- AAAA BBB CC Ddef __init__(self, iterable, keyNone):if key is None:key lambda x: xself.keyfunc keyself.it iter(iterable)self.tgtkey self.currkey self.currvalue object()def __iter__(self):return selfdef __next__(self):self.id object()while self.currkey self.tgtkey:self.currvalue next(self.it) # Exit on StopIterationself.currkey self.keyfunc(self.currvalue)self.tgtkey self.currkeyreturn (self.currkey, self._grouper(self.tgtkey, self.id))def _grouper(self, tgtkey, id):while self.id is id and self.currkey tgtkey:yield self.currvaluetry:self.currvalue next(self.it)except StopIteration:returnself.currkey self.keyfunc(self.currvalue)
例子1
import itertoolsfruits [hippopotamus, pear, peach, grape, banana, cherry,mulberry, persimmon,strawberry, watermelon, apple, pomegranate]newfruits itertools.groupby(fruits, keylen)
# newfruits itertools.groupby(fruits, keylambda x:x[0])
for k,v in newfruits:print(f---{k}---)for vit in v:print(vit)’’’
---12---
hippopotamus
---4---
pear
---5---
peach
grape
---6---
banana
cherry
---8---
mulberry
---9---
persimmon
---10---
strawberry
watermelon
---5---
apple
---11---
pomegranate
‘’‘
从上面的例子看有两个5的分组。
例子2
import itertoolsfruits [hippopotamus, pear, peach, grape, banana, cherry,mulberry, persimmon,strawberry, watermelon, apple, pomegranate]# newfruits itertools.groupby(fruits, keylen)
newfruits itertools.groupby(fruits, keylambda x:x[0])
for k,v in newfruits:print(f---{k}---)for vit in v:print(vit)
’’’
---h---
hippopotamus
---p---
pear
peach
---g---
grape
---b---
banana
---c---
cherry
---m---
mulberry
---p---
persimmon
---s---
strawberry
---w---
watermelon
---a---
apple
---p---
pomegranate
‘’‘
有3个p的分组。说明group是不进行排序的需要我们事先进行排序。
import itertoolsfruits [hippopotamus, pear, peach, grape, banana, cherry,mulberry, persimmon,strawberry, watermelon, apple, pomegranate]fruitsnew sorted(fruits, keylambda x:x[0])
# newfruits itertools.groupby(fruits, keylen)
newfruits itertools.groupby(fruitsnew, keylambda x:x[0])
for k,v in newfruits:print(f---{k}---)for vit in v:print(vit)‘’
---a---
apple
---b---
banana
---c---
cherry
---g---
grape
---h---
hippopotamus
---m---
mulberry
---p---
pear
peach
persimmon
pomegranate
---s---
strawberry
---w---
watermelon
‘
切片迭代器
itertools.islice(iterable, stop)
itertools.islice(iterable, start, stop[, step])
获取iterable的一段切片start是开始位置stop是结束位置step是步长。
等价于iterable[start:stop:step]
import itertoolsfruits [mango, pear, peach, grape, banana, cherry,apricot, persimmon,medlar, watermelon, apple, pomegranate, currant, blackberry, avocado,walnut, walnut, coconut, bilberry, plum]for it in itertools.islice(fruits, 3, 10, 2):print(it)‘’
grape
cherry
persimmon
watermelon
‘
重叠对迭代器
itertools.pairwise(iterable)
返回从输入 iterable 中获取的连续重叠对。
输出迭代器中 2 元组的数量将比输入的数量少一个。 如果输入可迭代对象中少于两个值则它将为空。
import itertoolsfruits [mango, pear, peach, grape, banana]for it in itertools.pairwise(fruits):print(it)for it in itertools.pairwise(ABCDE):print(it)‘’
(mango, pear)
(pear, peach)
(peach, grape)
(grape, banana)
(A, B)
(B, C)
(C, D)
(D, E)
‘ 多参数map
itertools.starmap(function, iterable)
map函数只能接受单个参数startmap可以接受多个参数要求iterable是一个元素的迭代对象类似于[(a1,a2,...),(b1,b2,...),...]每一个元组是function的一组参数。
import itertoolsdatalist [(2,4), (3,7), (19,14), (20,31)]sumlist list(itertools.starmap(lambda x,y:xy, datalist))
print(sumlist) #[6, 10, 33, 51],类似于 24,37,1914,2031multilist list(itertools.starmap(lambda x,y:x*y, datalist))
print(multilist) #[8, 21, 266, 620]powlist list(itertools.starmap(lambda x,y:x**y, datalist))
print(powlist) #[16, 2187, 799006685782884121, 21474836480000000000000000000000000000000]排列组合迭代器
排列迭代器
itertools.permutations(iterable, rNone)
连续返回由 iterable 元素生成长度为 r 的排列。
如果 r 未指定或为 None r 默认设置为 iterable 的长度这种情况下生成所有全长排列。
import itertoolsfruits [mango, pear, peach]for it in itertools.permutations(fruits):print(it)’’’
(mango, pear, peach)
(mango, peach, pear)
(pear, mango, peach)
(pear, peach, mango)
(peach, mango, pear)
(peach, pear, mango)
‘’‘
如果设置了r是从iterable选出r个元素进行全排列数据量会比较大
import itertoolsfruits [mango, pear, peach, grape, banana]for it in itertools.permutations(fruits, 3):print(it)’’’
(mango, pear, peach)
(mango, pear, grape)
(mango, pear, banana)
(mango, peach, pear)
(mango, peach, grape)
(mango, peach, banana)
(mango, grape, pear)
(mango, grape, peach)
(mango, grape, banana)
(mango, banana, pear)
(mango, banana, peach)
(mango, banana, grape)
(pear, mango, peach)
(pear, mango, grape)
(pear, mango, banana)
(pear, peach, mango)
(pear, peach, grape)
(pear, peach, banana)
(pear, grape, mango)
(pear, grape, peach)
(pear, grape, banana)
(pear, banana, mango)
(pear, banana, peach)
(pear, banana, grape)
(peach, mango, pear)
(peach, mango, grape)
(peach, mango, banana)
(peach, pear, mango)
(peach, pear, grape)
(peach, pear, banana)
(peach, grape, mango)
(peach, grape, pear)
(peach, grape, banana)
(peach, banana, mango)
(peach, banana, pear)
(peach, banana, grape)
(grape, mango, pear)
(grape, mango, peach)
(grape, mango, banana)
(grape, pear, mango)
(grape, pear, peach)
(grape, pear, banana)
(grape, peach, mango)
(grape, peach, pear)
(grape, peach, banana)
(grape, banana, mango)
(grape, banana, pear)
(grape, banana, peach)
(banana, mango, pear)
(banana, mango, peach)
(banana, mango, grape)
(banana, pear, mango)
(banana, pear, peach)
(banana, pear, grape)
(banana, peach, mango)
(banana, peach, pear)
(banana, peach, grape)
(banana, grape, mango)
(banana, grape, pear)
(banana, grape, peach)
‘’‘ 组合迭代器
itertools.combinations(iterable, r)
返回由输入 iterable 中元素组成长度为 r 的子序列在iterable中任选r个元素的组合序列。
alist itertools.combinations(ABCDEFG, 3)
print(list(alist))#[(A, B, C), (A, B, D), (A, B, E), (A, B, F), (A, B, G), (A, C, D), (A, C, E), (A, C, F), (A, C, G), (A, D, E), (A, D, F), (A, D, G), (A, E, F), (A, E, G), (A, F, G), (B, C, D), (B, C, E), (B, C, F), (B, C, G), (B, D, E), (B, D, F), (B, D, G), (B, E, F), (B, E, G), (B, F, G), (C, D, E), (C, D, F), (C, D, G), (C, E, F), (C, E, G), (C, F, G), (D, E, F), (D, E, G), (D, F, G), (E, F, G)]可重复的组合迭代器
itertools.combinations_with_replacement(iterable, r)
上面的那个组合迭代器选的元素都是不同的这个可以选自己。
alist itertools.combinations_with_replacement(ABCDEFG, 3)
print(list(alist))#[(A, A, A), (A, A, B), (A, A, C), (A, A, D), (A, A, E), (A, A, F), (A, A, G), (A, B, B), (A, B, C), (A, B, D), (A, B, E), (A, B, F), (A, B, G), (A, C, C), (A, C, D), (A, C, E), (A, C, F), (A, C, G), (A, D, D), (A, D, E), (A, D, F), (A, D, G), (A, E, E), (A, E, F), (A, E, G), (A, F, F), (A, F, G), (A, G, G), (B, B, B), (B, B, C), (B, B, D), (B, B, E), (B, B, F), (B, B, G), (B, C, C), (B, C, D), (B, C, E), (B, C, F), (B, C, G), (B, D, D), (B, D, E), (B, D, F), (B, D, G), (B, E, E), (B, E, F), (B, E, G), (B, F, F), (B, F, G), (B, G, G), (C, C, C), (C, C, D), (C, C, E), (C, C, F), (C, C, G), (C, D, D), (C, D, E), (C, D, F), (C, D, G), (C, E, E), (C, E, F), (C, E, G), (C, F, F), (C, F, G), (C, G, G), (D, D, D), (D, D, E), (D, D, F), (D, D, G), (D, E, E), (D, E, F), (D, E, G), (D, F, F), (D, F, G), (D, G, G), (E, E, E), (E, E, F), (E, E, G), (E, F, F), (E, F, G), (E, G, G), (F, F, F), (F, F, G), (F, G, G), (G, G, G)]笛卡尔集迭代器
itertools.product(*iterables, repeat1)
可迭代对象输入的笛卡儿积。
大致相当于生成器表达式中的嵌套循环。例如 product(A, B) 和 ((x,y) for x in A for y in B) 返回结果一样。
嵌套循环像里程表那样循环变动每次迭代时将最右侧的元素向后迭代。这种模式形成了一种字典序因此如果输入的可迭代对象是已排序的笛卡尔积元组依次序发出。
要计算可迭代对象自身的笛卡尔积将可选参数 repeat 设定为要重复的次数。例如product(A, repeat4) 和 product(A, A, A, A) 是一样的。
import itertoolsfruits [mango, pear, peach]
ids [1, 2]for it in itertools.product(fruits, ids):print(it)‘’
(mango, 1)
(mango, 2)
(pear, 1)
(pear, 2)
(peach, 1)
(peach, 2)
‘
import itertoolsfruits [mango, pear, peach]
ids [1, 2]for it in itertools.product(fruits, repeat2):print(it)print(----)
for it in itertools.product(fruits, fruits):print(it)‘’
(mango, mango)
(mango, pear)
(mango, peach)
(pear, mango)
(pear, pear)
(pear, peach)
(peach, mango)
(peach, pear)
(peach, peach)
----
(mango, mango)
(mango, pear)
(mango, peach)
(pear, mango)
(pear, pear)
(pear, peach)
(peach, mango)
(peach, pear)
(peach, peach)
‘
