python进阶之iterstools模块详解

最新推荐文章于 2024-03-03 12:21:46 发布
最新推荐文章于 2024-03-03 12:21:46 发布
阅读量1.5k 收藏 4
点赞数 1
分类专栏： python iterstools 文章标签： python iterstools
原文链接：https://www.jianshu.com/p/752052dbeaca
版权

iterstools很强大,务必要掌握
https://docs.python.org/3/library/itertools.html

1. 概览

无限迭代器

迭代器参数结果例
count()start, [step]start, start+step, start+2*step, ...count(10) --> 10 11 12 13 14 ...
cycle()pp0, p1, ... plast, p0, p1, ...cycle('ABCD') --> A B C D A B C D ...
repeat()elem [,n]elem，elem，elem，...无休止或多达n次repeat(10, 3) --> 10 10 10

处理输入序列迭代器

迭代器参数结果例
accumulate()p [,func]p0, p0+p1, p0+p1+p2, ...accumulate([1,2,3,4,5]) --> 1 3 6 10 15
chain()p, q, ...p0, p1, ... plast, q0, q1, ...chain('ABC', 'DEF') --> A B C D E F
chain.from_iterable()可迭代p0, p1, ... plast, q0, q1, ...chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
compress()数据，选择器(d[0] if s[0]), (d[1] if s[1]), ...compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile()pred, seqseq[n]，seq[n+1]，当pred失败时开始dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
filterfalse()pred, seqpred(elem)为false的seq的元素filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
groupby()iterable[, keyfunc]通过keyfunc(v)的值分组的子迭代器---
islice()seq, [start,] stop [, step]元素从seq[start:stop:step]islice('ABCDEFG', 2, None) --> C D E F G
starmap()功能报func(seq[0]), func(seq[1]), ...starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
takewhile()pred, seqseq[0]，seq[1]，直到pred失败takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
tee()it，nit1，it2，... itn将一个迭代器拆分为n---
zip_longest()p, q, ...(p[0], q[0]), (p[1], q[1]), ...zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

组合生成器

迭代器参数结果
product()p, q, ... [repeat=1]笛卡尔积，相当于嵌套for循环
permutations()p[, r]r长度元组，所有可能的顺序，没有重复的元素
combinations()p, rr长度元组，按排序顺序，没有重复的元素
combinations_with_replacement()p, rr长度元组，按排序顺序，具有重复的元素
product('ABCD', repeat=2)---AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)---AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)---AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)---AA AB AC AD BB BC BD CC CD DD

2. itertools 函数(无限迭代器)

2.1 itertools.count(start=0, step=1)

  • 创建一个迭代器，生成从start开始的连续的数，start默认为0，step默认为1
  • 源代码
def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) -> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step
  • 使用
from itertools import *
for i in zip(count(1),['a','b','c']):
    print(i)

(1, 'a')
(2, 'b')
(3, 'c')

2.2 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 element
        saved.append(element)
    # 反复执行副本
    while saved:
        for element in saved:
            yield element
  • 使用
from itertools import *

i = 0
for item in cycle(['a', 'b', 'c']):
    i += 1
    if i == 7:
        break
    print (i, item)

1 a
2 b
3 c
4 a
5 b
6 c

2.3 itertools.repeat(object[, times])

  • 创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。
  • 源代码
def repeat(object, times=None):
    # repeat(10, 3) --> 10 10 10
    # 如果times=None，无限循环
    if times is None:
        while True:
            yield object
    else:
        for i in range(times):
            yield object
  • 使用
from itertools import *
for i in repeat('sweet_honey', 3):
    print (i)

sweet_honey
sweet_honey
sweet_honey

3. itertools 函数(处理输入序列迭代器)

3.1 itertools.accumulate(iterable[, func])

  • 创建一个迭代器，返回函数指定的操作方式，默认为累加和。
  • 源代码
import operator
def accumulate(iterable, func=operator.add):
    'Return running totals'
    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15
    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
    # 生成一个迭代器
    it = iter(iterable)
    try:
        # 获取下一个值
        total = next(it)
    # 遇到StopIteration，就返回空
    except StopIteration:
        return
    # 如果没有报错，就返回total
    yield total
    # 从2开始累加
    for element in it:
        total = func(total, element)
        yield total
  • 使用
from itertools import accumulate
import operator
print(list(accumulate(range(10))))

[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
print(list(accumulate(range(1,5), func = operator.mul)))

[1, 2, 6, 24]
print(list(list(accumulate(range(5,1,-1), max))))

[5, 5, 5, 5]

3.2 itertools.chain(*iterables)

  • 将几个可迭代的容器依次迭代
  • 源代码
def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element
  • 使用
from itertools import *

for i in chain([1, 2, 3], ['a', 'b', 'c']):
    print (i)

1
2
3
a
b
c

3.3 chain.from_iterable()

  • 将可迭代容器里面的元素再次进行迭代一次
  • 源代码
def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element
  • 使用
from itertools import *

for i in chain([['abc', 'bca','cba'],'abcd']):
    print(i)

['abc', 'bca', 'cba']
abcd

for i in chain.from_iterable([['abc', 'bca','cba'],'abcd']):
    print(i)

abc
bca
cba
a
b
c
d

3.4 itertools.compress(data, selectors)

  • 两个参数分别为data, selectors, 根据selectors中的真假情况返回data中的元素
  • 源代码
def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)
  • 使用
from itertools import *
for i in compress('ABCDEF', [1,0,1,0,1,1]) :
    print(i)

A
C
E
F

3.5 itertools.dropwhile(predicate, iterable)

  • 当predicate返回True时，跳过元素。一旦函数返回False，则开始收集剩下的所有元素到循环器
  • 源代码
def dropwhile(predicate, iterable):
    # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
    iterable = iter(iterable)
    # 一直在找false
    for x in iterable:
        if not predicate(x):
            yield x
            break
    # 找到false 跳出上面的循环，进入这个循环直到结束
    for x in iterable:
        yield x
  • 使用
from itertools import *

for i in dropwhile(lambda x: x<5, [1,4,6,4,1]) :
    print(i)

6
4
1

3.6 itertools.filterfalse(predicate, iterable)

  • 当predicate返回False时，才将iterable中的元素添加进循环器
  • 源代码
def filterfalse(predicate, iterable):
    # filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
    if predicate is None:
        predicate = bool
    for x in iterable:
        if not predicate(x):
            yield x
  • 使用
from itertools import *

for i in filterfalse(lambda x: x<5, [1,4,6,4,1]) :
    print(i)

6

3.7 itertools.groupby(iterable[, key])

  • 将key的结果作用于iterable中的元素，将拥有相同返回结果的元素加入到循环器中，该函数之前需要确保iterable是经过排序的
  • 源代码
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 D
    def __init__(self, iterable, key=None):
        if key is None:
            key = lambda x: x
        self.keyfunc = key
        self.it = iter(iterable)
        self.tgtkey = self.currkey = self.currvalue = object()
    def __iter__(self):
        return self
    def __next__(self):
        while self.currkey == self.tgtkey:
            self.currvalue = next(self.it)    # Exit on StopIteration
            self.currkey = self.keyfunc(self.currvalue)
        self.tgtkey = self.currkey
        return (self.currkey, self._grouper(self.tgtkey))
    def _grouper(self, tgtkey):
        while self.currkey == tgtkey:
            yield self.currvalue
            try:
                self.currvalue = next(self.it)
            except StopIteration:
                return
            self.currkey = self.keyfunc(self.currvalue)
  • 使用
from itertools import *

def height_classify(h):
    if h > 180:
        return 'tall'
    elif h < 160:
        return 'short'
    else:
        return 'middle'


friends = [192, 158, 168, 195, 185, 170, 135, 174, 182]
friends = sorted(friends, key=height_classify)
for m, n in groupby(friends, key=height_classify):
    print(m)
    print(list(n))

middle
[168, 170, 174]
short
[158, 135]
tall
[192, 195, 185, 182]

3.7 itertools.islice(iterable, stop)

  • 根据索引来选取迭代器的项
  • 源代码
def islice(iterable, *args):
    # islice('ABCDEFG', 2) --> A B
    # islice('ABCDEFG', 2, 4) --> C D
    # islice('ABCDEFG', 2, None) --> C D E F G
    # islice('ABCDEFG', 0, None, 2) --> A C E G
    s = slice(*args)
    it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
    nexti = next(it)
    for i, element in enumerate(iterable):
        if i == nexti:
            yield element
            nexti = next(it)
  • 使用
from itertools import *

for i in islice(count(), 5, 10):
    print (i, end=' ')

5 6 7 8 9

for i in islice(count(), 0, 100, 10):
    print (i, end=' ')

0 10 20 30 40 50 60 70 80 90

3.8 itertools.starmap(function, iterable)

  • 用iterable 里面的项，构造function函数
def starmap(function, iterable):
    # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
    for args in iterable:
        yield function(*args)
  • 使用
from itertools import *

values = [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
for i in starmap(lambda x,y:(x, y, x*y), values):
    print ('%d * %d = %d' % i)

0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36

3.9 itertools.takewhile(predicate, iterable)

  • 和dropwhile相反，当predicate返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器
  • 源代码
def takewhile(predicate, iterable):
    # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break
  • 使用
from itertools import *

for i in takewhile(lambda x: x<5, [1,4,6,4,1]) :
    print(i)
1
4

for i in dropwhile(lambda x: x<5, [1,4,6,4,1]) :
    print(i)

6
4
1

3.10 itertools.tee(iterable[, n=2])

  • 从单个的iterable返回n个独立的循环器
  • 源代码
def tee(iterable, n=2):
    it = iter(iterable)
    deques = [collections.deque() for i in range(n)]
    def gen(mydeque):
        while True:
            if not mydeque:             # when the local deque is empty
                newval = next(it)       # fetch a new value and
                for d in deques:        # load it to all the deques
                    d.append(newval)
            yield mydeque.popleft()
    return tuple(gen(d) for d in deques)
  • 使用
from itertools import *

for i in tee([['abc', 'bca','cba'],'abcd']):
    for j in i:
        print(j)

['abc', 'bca', 'cba']
abcd
['abc', 'bca', 'cba']
abcd

3.11 itertools.zip_longest(*iterables, fillvalue=None)

  • 创建一个迭代器，聚合来自每个迭代器的元素。如果迭代的长度不均匀，那么缺失值将用 fillvalue 填充。迭代继续，直到最长可迭代被耗尽。
  • 源代码
class ZipExhausted(Exception):
    pass

def zip_longest(*args, **kwds):
    # zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
    fillvalue = kwds.get('fillvalue')
    counter = len(args) - 1
    def sentinel():
        nonlocal counter
        if not counter:
            raise ZipExhausted
        counter -= 1
        yield fillvalue
    fillers = repeat(fillvalue)
    iterators = [chain(it, sentinel(), fillers) for it in args]
    try:
        while iterators:
            yield tuple(map(next, iterators))
    except ZipExhausted:
        pass
  • 使用
from itertools import *

for i in zip_longest('abcd','123',fillvalue='*'):
    print(i)

('a', '1')
('b', '2')
('c', '3')
('d', '*')

4. itertools 函数(组合生成器)

4.1 itertools.product(*iterables, repeat=1)

  • 笛卡尔乘积
  • 源代码
def product(*args, repeat=1):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    pools = [tuple(pool) for pool in args] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)
  • 使用
from itertools import *
for i in product('abc','xy'):
    print(i)

('a', 'x')
('a', 'y')
('b', 'x')
('b', 'y')
('c', 'x')
('c', 'y')

4.2 itertools.permutations(iterable, r=None)

  • 全排列
  • 源代码
def permutations(iterable, r=None):
    # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
    # permutations(range(3)) --> 012 021 102 120 201 210
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    if r > n:
        return
    indices = list(range(n))
    cycles = list(range(n, n-r, -1))
    yield tuple(pool[i] for i in indices[:r])
    while n:
        for i in reversed(range(r)):
            cycles[i] -= 1
            if cycles[i] == 0:
                indices[i:] = indices[i+1:] + indices[i:i+1]
                cycles[i] = n - i
            else:
                j = cycles[i]
                indices[i], indices[-j] = indices[-j], indices[i]
                yield tuple(pool[i] for i in indices[:r])
                break
        else:
            return
  • 使用
from itertools import *

for i in permutations('abcd', r=2):
    print(i, end='')

('a', 'b') ('a', 'c') ('a', 'd') ('b', 'a') ('b', 'c') ('b', 'd') ('c', 'a') ('c', 'b') ('c', 'd') ('d', 'a') ('d', 'b') ('d', 'c')

4.3 itertools.combinations(iterable, r)

  • 创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (不带重复)
  • 源代码
def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)
  • 使用
from itertools import *

for i in combinations('abcd',r=2):
    print(i, end=' ')

('a', 'b') ('a', 'c') ('a', 'd') ('b', 'c') ('b', 'd') ('c', 'd')

4.4 itertools.combinations_with_replacement(iterable, r)

  • 创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (带重复)
  • 源代码
def combinations_with_replacement(iterable, r):
    # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
    pool = tuple(iterable)
    n = len(pool)
    if not n and r:
        return
    indices = [0] * r
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != n - 1:
                break
        else:
            return
        indices[i:] = [indices[i] + 1] * (r - i)
        yield tuple(pool[i] for i in indices)
  • 使用
from itertools import *

for i in combinations_with_replacement('abcd',r=2):
    print(i, end=' ')

('a', 'a') ('a', 'b') ('a', 'c') ('a', 'd') ('b', 'b') ('b', 'c') ('b', 'd') ('c', 'c') ('c', 'd') ('d', 'd')

参考文献

  1. https://docs.python.org/3/library/itertools.html#module-itertools
  2. https://www.rddoc.com/doc/Python/3.6.0/zh/library/itertools/
  3. http://www.wklken.me/posts/2013/08/20/python-extraitertools.html#itertoolsizip_longestiterables-fillvalue
  4. http://blog.csdn.net/calling_wisdom/article/details/41219829
冰阔箩
关注
专栏目录
Python的Tools模块
PanDaoxi
09-18 3982
Python的Tools模块.
Python Iteration，itertools（Python迭代器，itertool个人总结）
passer_zzy的博客
07-29 4927
1.迭代是什么？ 首先看三个例子：当迭代的对象是一个list对象的时候，他打印的是每一个list对象 for i in [1,2,3,4]: pritn(i) 打印的结果： 1 2 3 4当我们迭代的对象是一个字符串的时候，他会一一打印出字符串的每一个字符 for c in ‘Python’: print(c) 打印的结果是： P y t h o n
python 中的itertools
qq_44896301的博客
01-15 253
在Python中，迭代器（Iterator）是常用来做惰性序列的对象，只有当迭代到某个值的时候，才会进行计算得出这个值。因此，迭代器可以用来存储无限大的序列，这样我们就不用把他一次性放在内存中，而只在需要的时候进行计算。所以，对于读取大文件或者无线集合，最好是使用迭代器。Python的内置模块itertools就是用来操作迭代器的一个模块，包含的函数都是能够创建迭代器来用于for循环或者next()。其中函数主要可以分为三类，分别是无限迭代器，有限迭代器，组合迭代器。
python的tool模块_python ***测试工具模块：pwntools
weixin_39617473的博客
12-18 279
pwntools是一个ctf框架和漏洞利用开发库，用Python开发，由rapid设计，旨在让使用者简单快速的编写exploit。安装：pwntools对Ubuntu 12.04和14.04的支持最好，但是绝大多数的功能也支持Debian, Arch, FreeBSD, OSX, 等等，确保安装以下系统库。BinutilsUbuntuMac OS XAlternate OSesCapstoneUb...
python工具的功能介绍_Python功能工具
从零开始的教程世界
07-15 770
python工具的功能介绍One of the biggest power which Python demonstrates is providing tools for writing reusable code. In this lesson, we will learn about Python functools module, which makes writing reusable ...
Python进阶.pdf
04-11
《Python进阶》是一本专为已经掌握Python基础的开发者准备的进阶指南。书中涵盖了Python编程中的高级特性和实践技巧，旨在帮助读者深入理解Python的内在机制，并提升编程效率和代码质量。以下是对书中部分关键知识点...
python进阶教程之模块（module）介绍
12-25
在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。 引入模块 我们先写一个first.py文件，内容如下： 复制代码 代码如下: def laugh():  print ‘HaHaHaHa’ 再写一个second.py，并...
Python进阶：面向对象编程与模块化设计
06-29
Python进阶：面向对象编程与模块化设计Python进阶：面向对象编程与模块化设计Python进阶：面向对象编程与模块化设计Python进阶：面向对象编程与模块化设计Python进阶：面向对象编程与模块化设计Python进阶：面向对象...
python pytest进阶之xunit fixture详解
01-01
前言 今天我们再说一下pytest框架和unittest框架相同的fixture的使用， 了解unittest的同学应该知道我们在初始化环境和销毁工作时，unittest使用的是setUp，tearDown方法，那么在pytest框架中同样存在类似的方法，...
Python进阶之路：笔记与源代码指南.zip
最新发布
08-15
《Python进阶之路：笔记与源代码指南》是一部专为渴望深化Python编程技能的开发者设计的宝贵资源。这本指南不仅涵盖了Python编程语言的进阶知识，如高级数据结构、并发编程、网络编程、数据库操作及Web开发等核心...
Python学习笔记（十三）- 迭代和推导式（Iterations and Comprehension）
Enderman_xiaohei的博客
02-18 540
1.for 循环和可迭代对象是如何关联的？ 答：for 循环使用迭代协议（iteration protocol）来遍历它正在迭代的可迭代对象中的项。它首先通过将对象传递到 iter() 来从可迭代对象（iterable）获取迭代器（iterator），并且在 Python 3.X 中每次迭代中调用此迭代器对象的 __next__ 方法，并捕获 StopIteration 异常以确定何时停止循环。...
python itertools 模块讲解
dichengpai8268的博客
10-17 152
1、介绍itertools 是python的迭代器模块，itertools提供的工具相当高效且节省内存。 使用这些工具，你将能够创建自己定制的迭代器用于高效率的循环。 - 无限迭代器 　itertools包自带了三个可以无限迭代的迭代器。这意味着，当你使用他们时，你要知道要的到底是最终会停止的迭代器，还是需要无限地迭代鞋去。 （1）count(初值=0, 步长=1):count 迭代...
python 仿真模块_python collection、itertools模块
weixin_39905037的博客
12-08 148
一、collections模块--容器数据库类型1、defaultdict:接受 default_factory作为变量。(1)设置 int作为 default_factory，使得dedaultdict在计数方面发挥作用。from collections importdefaultdicts="mississippi"d=defaultdict(int)for k ins:d[k]+=1pr...
python中iter()函数和__iter__方法研究_Python iter()函数用法实例分析
weixin_39954464的博客
12-07 727
本文实例讲述了Python iter()函数用法。分享给大家供大家参考，具体如下：python中的迭代器用起来非常灵巧，不仅可以迭代序列，也可以迭代表现出序列行为的对象，例如字典的键、一个文件的行，等等。迭代器就是有一个next()方法的对象，而不是通过索引来计数。当使用一个循环机制需要下一个项时，调用迭代器的next()方法，迭代完后引发一个StopIteration异常。但是迭代器只能向后移动...
epoch（当前 epoch 数量）和iters（当前迭代数）
weixin_45594172的博客
03-03 2121
当每个批次的数据都被模型处理过一次后，一个 epoch 结束，此时迭代次数会重新从 1 开始计数，直到完成指定的 epoch 数量。例如，如果您设置了训练的总 epoch 数量为 10，则在训练开始时，该值为 1，当模型完成了对整个数据集的一次完整训练后，即 epoch 1 结束，该值增加为 2，以此类推，直到训练完成所有指定的 epoch 数量。例如，如果训练数据集有1000个样本，每次训练时从中随机选择一个batch进行训练，那么当模型训练完成了1000次batch，也就是一个epoch。
python itertools模块详解
热门推荐
嘤嘤的博客
02-11 2万+
目录简介无穷迭代器count()cycle()repeat()有限迭代器chain()groupby()accumulate()组合迭代器product()permutations()combinations()combinations_with_replacement() 简介 itertools，是python的一个内置模块，功能强大，主要用于高效循环创建迭代器。注意一点，他返回的不是list，而是iterator 无穷迭代器 count() count(start, [step])会创建一个无限迭代器
超简单理解卷积神经网络
a1053904672的博客
03-24 992
人工智能发展到现在，出现了很多很多的神将网络，但是神经网络再多，不变的还是全连接层 全连接层成为了一种通用的数学模型用于回归和分类任务，它本质上就是拟合曲线（决策边界曲线或回归曲线），其拟合曲线的方式是基于连续的定义的，就跟微积分一样，任意一条曲线都可以由无数直线构成，任何曲线在其局部无穷小时都是线性的，而神经网络通过非线性变换产生了很多条这样的直线，这些直线组合起来就构成了目标曲线，对于每一个...
Python 迭代器的使用
Jairo的博客
02-24 4528
Python 迭代器的使用
Python 性能优化｜itertools.chain 和 itertools.chain.from_iterable
长行
11-07 258
Python性能实例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值