精华内容
下载资源
问答
  • Python 常用迭代函数总结
    千次阅读
    更多相关内容
  • 对分形图形的一种构造方法——随机迭代函数系统 ,给出了确定一个随机迭代函数系统的原图像经过仿射变换后得到的新图像所对应的随机迭代函数系统的具体步骤 ,最后用平移、旋转、拉伸和对称变换的例子作了详细的说明。
  • 4、DAX的常用迭代函数详解

    千次阅读 2020-09-14 15:48:05
    本篇文章详细讲解了DAX的常用迭代函数的各种知识,包括语法结构、行为方式、计值环境以及注意事项 等内容。


    一、前言

      DAX语言的特点我觉得可以用一句话来概括,那就是:从基础数据源中抽取数据并经过转换与处理后进行聚合以得出结果。其中,聚合操作在许多情况下都是通过迭代函数来完成的,因此如果没有掌握好迭代函数,那么DAX表达式在计算的最后一步就很容易出现错误,以至于功亏一篑,也有可能会因为掌握的迭代函数过少而使得许多奇思妙想无法实现。因此,掌握迭代函数是DAX的学习过程中必不可少的一部分。

      可能有人会疑惑:聚合操作难道不是通过SUM、MAX与MIN等等聚合函数来完成的吗?,这个疑问可以说是正确的但也可以说是错误的,因为像SUM、MAX等等这些聚合函数其实都是它们对应的迭代函数的简化形式,它们只是一种为了方便使用而诞生的语法糖函数,如果不怕麻烦完全可以用迭代函数重写聚合函数。在下面的介绍中,我也会介绍几个常用聚合函数的等价写法。

    二、神秘的X迭代函数

    2.1 迭代函数的介绍

      DAX里的迭代函数的迭代与广义上的迭代的含义有所不同,广义上的迭代指的是重复反馈过程的活动,其目的通常是为了逼近所需目标或结果,将每一次对过程的重复称为一次“迭代”,而每一次迭代得到的结果会作为下一次迭代的初始值。而在DAX里的迭代可以理解为遍历,迭代函数会遍历在数据模型中指定表的可见数据,并为表的每一行执行相同的 DAX 表达式,在遍历完表后再根据不同的迭代函数执行不同的后续操作,例如:SUMX的后续操作是求和、MAXX的后续操作是求最大值、RANKX的后续操作是排序等等。

      DAX里的迭代函数有很多,每一个迭代函数都有其各自的作用,但大致可以分为以下两类:

    1. 以X结尾的迭代函数,如:SUMX、MAXX、MINX、AVERAGEX、COUNTX、COUNTAX、PRODUCTX 等等,这些函数的主要特点可以概况为:结果为标量数值
    2. 另一类迭代函数要么结果不是标量数值,要么就是行为比较特殊,如:FILTER、ADDCOLUMNS、SELECTCOLUMNS、RANKX、TOPN、FIRSTNONBLANK 等等

      由于迭代函数过多,而且函数作用不同且需要注意的地方也有许多,在一篇文章里不可能全部介绍,所以本篇文章只介绍第一类的迭代函数以及FILTER,其余函数在以后的文章中讲解。

    2.2 迭代函数的行为

      虽说DAX的迭代函数有许多,但是这些迭代函数的行为方式与语法结构都是差不多的,仅仅是在遍历完表后的后续操作有所不同。因此,迭代函数的行为可以总结为如下:

    • Step1. 在数据模型中抽取迭代函数的参数(一般为第一参数)所指定的表在外部计值上下文中的可见数据,以确定迭代目标;

    • Step2. 为指定的表的可见数据创建行上下文;

    • Step3. 从指定的表的可见数据的第一条记录开始,在外部计值上下文以及迭代函数内部所创建的行上下文中计算其余参数(一般为第二参数),并依次迭代所有可见数据;

    • Step4. 对上一步计算出的其余参数的结果执行后续操作,一般为聚合操作,例如:SUMX 求和、MINX 取最小值、AVERAGEX 取平均值等等,以此类推。

      其实我的描述还是显得有些啰嗦了,但为了让所有人都能明白,所以再啰嗦点也无妨。而我的描述显得有些啰嗦的主要原因是因为:很多人都搞不懂迭代函数的计值流程,那为什么他们搞不懂这个计值流程呢?因为他们忽略了迭代函数的各个参数所处的计值环境不同这一事实!

      对于上文提到的第一类迭代函数来说,它们只有两个参数,第一个参数是用来确定迭代目标的表函数,第二参数是任意DAX表达式,主要是为第一参数的每一行数据计值。其中,第一参数所处的计值环境是迭代函数所处的外部计值环境,第二参数所处的计值环境既包括了迭代函数所处的外部计值环境,也包括了迭代函数内部对第一参数的表所创建的行上下文。要知道,一个DAX表达式,甚至是一个DAX函数,若它所处的计值环境不同,那么它所得到的结果也有可能会不同,很多人不能掌握DAX的原因就是因为不能理解计值环境。

    2.3 迭代函数的行为模拟

      对于迭代函数的行为以及计值环境这些东西,只是用文字说明可能显得枯燥和难以理解,所以下面我将在Excel里手动模拟SUMX这个迭代函数的行为(其余迭代函数的行为基本一致),并将手动模拟所得到的结果与DAX表达式计算得出的结果进行对比。具体要求的东西为:某个产品类别下的销售金额,对应DAX表达式如下:

    销售金额:=SUMX('T3销售','T3销售'[T3销售册数]*'T3销售'[T3销售单价])
    
    科技大类的销售金额:=CALCULATE([销售金额],'T0大类'[T0大类K]="1科技")
    

    2.3.1 在Excel进行手动模拟

      由于上面两个度量值执行计算的部分都是一样的,只是有无筛选的区别,所以在Excel里就只模拟[科技大类的销售金额]这个度量值,具体如下图:

    在这里插入图片描述
      这就是许多迭代函数的行为了,先获取指定表的可见数据,然后对每一行计值,最后根据不同的迭代函数执行不同的后续操作,在这里SUMX执行的是求和操作。

    2.3.2 使用DAX进行计算

      下面使用DAX来计算科技大类下的销售金额,再次给出所使用的DAX表达式:

    销售金额:=SUMX('T3销售','T3销售'[T3销售册数]*'T3销售'[T3销售单价])
    
    科技大类的销售金额:=CALCULATE([销售金额],'T0大类'[T0大类K]="1科技")
    

      结果如下图所示:

    在这里插入图片描述
      在上图中可以看到,[销售金额]这个度量值得到的结果为:7037,[科技大类的销售金额]这个度量值得到的结果为:2598,这与手动模拟所得到的结果是一致的。

      实际上,这两个度量值都是对SUMX('T3销售','T3销售'[T3销售册数]*'T3销售'[T3销售单价]) 这个迭代函数进行计算,仅仅只是所处的计值环境不同。对于[销售金额]这个度量值而言,它的外部计值环境没有筛选器也没有行上下文,所以它的外部计值环境是所有数据,也就是说’T3销售’这张表使用的是所有数据。而对于[科技大类的销售金额]这个度量值来说,其计算器:SUMX('T3销售','T3销售'[T3销售册数]*'T3销售'[T3销售单价]) 所处的外部计值环境只有一个关于产品的科技大类的筛选器,没有行上下文,所以在[科技大类的销售金额]这个度量值里的’T3销售’表使用的仅仅是数据模型中的可见数据,也就是属于科技大类的销售数据。然后,这两个度量值的内部虽然有行上下文,但是其第二参数并没有使用CALCULATE,所以不存在行上下文转换的情况,因此SUMX只需要考虑外部筛选上下文就可以了,所以两个度量值得到的结果才不同。

    2.4 常用的迭代函数

      虽然各个迭代函数的作用不同,但是它们的行为模式和语法结构都是一致的,经过上面的讲解,相信对迭代函数的行为都有了一定的了解,因此在这里我不会详细地演示每一个迭代函数的行为,只介绍它们的语法结构和注意事项。

      在DAX中,常用的数据类型一般为:数值、文本、逻辑值、日期以及空值,而不同的迭代函数在聚合的过程中所支持的数据类型也是有所不同的。由于聚合结果为标量数值的迭代函数一般都不会对逻辑值和日期进行聚合,并且都忽略空值,因此为了方便记忆,我将常用的迭代函数分为了两类,一类是只支持数值,另一类则是同时支持数值和文本。

      此外,对于逻辑值,许多迭代函数都是不支持的,但当你遇到以A结尾的聚合函数或倒数第二个字母为A的迭代函数时就需要注意了,因为这些聚合函数或者迭代函数一般都支持逻辑值,例如:COUNTAX、MAXA、MINA、AVERAGEA等等,一般以聚合函数居多。

    2.4.1 只支持数值的迭代函数

    • SUMX
    SUMX ( <Table>, <Expression> )
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后将<Expression>所得到的所有结果进行求和。SUMX只考虑列中的数值,忽略空值、文本、逻辑值。

      注意事项:SUMX也可以对日期进行聚合,但实际上是对日期所代表的数值进行累加,因此并无实际意义。

    • AVERAGEX
    AVERAGEX(<Table>,<Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后对<Expression>所得到的所有结果计算算术平均值。AVERAGEX只考虑列中的数值,忽略空值、文本、逻辑值。

      注意事项:AVERAGEX忽略空值将改变分母的值,例如:有10个值的列中,空值占了3个,那么在求平均的时候,分母应该为7,而不是10。此外,AVERAGEX也可以对日期进行聚合,但实际上是对日期所代表的数值求平均,因此并无实际意义。

    • PRODUCTX
    PRODUCTX(<Table>, <Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后将<Expression>所得到的所有结果相乘。PRODUCTX只考虑列中的数值,忽略空值、文本、逻辑值。

    2.4.2 同时支持数值和文本的迭代函数

    • MAXX
    MAXX(<Table>,<Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后从<Expression>所得到的所有结果里取最大值。MAXX支持数值、文本、日期,忽略空值,不支持逻辑值。

      注意事项:MAX与MAXX支持文本,是按照字符顺序来取最大值的。而MAXA也支持文本,但却是将文本视为0。虽然都是支持文本,但支持的方式略有不同,需要注意。

    • MINX
    MINX(<Table>,<Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后从<Expression>所得到的所有结果里取最小值。MINX支持数值、文本、日期,忽略空值,不支持逻辑值。

      注意事项:MIN与MINX支持文本,是按照字符顺序来取最小值的。而MINA也支持文本,但却是将文本视为0。虽然都是支持文本,但支持的方式略有不同,需要注意。

    • COUNTX
    COUNTX(<Table>,<Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后从<Expression>所得到的所有结果里计算非空值的行数。COUNTX支持数值、文本、日期,忽略空值,不支持逻辑值

    • COUNTAX
    COUNTAX(<Table>,<Expression>)
    

      迭代<Table>的所有可见数据并对<Expression>计值,最后从<Expression>所得到的所有结果里计算非空值的行数。COUNTAX支持数值、文本、日期,忽略空值,支持逻辑值

    2.5 几个聚合函数的等价写法

      前面说过,聚合函数是对应迭代函数的简化形式,那么在这里将给出几个聚合函数的等价写法,具体如下:

    1、SUM

    SUM('Table'[ColumnName])
    
    ---- 等价于 ----
    
    SUMX('Table','Table'[ColumnName])
    

    2、AVERAGE

    AVERAGE('Table'[ColumnName])
    
    ---- 等价于 ----
    
    AVERAGEX('Table','Table'[ColumnName])
    

    3、MAX

    MAX('Table'[ColumnName])
    
    ---- 等价于 ----
    
    MAXX('Table','Table'[ColumnName])
    

      其它的聚合函数的等价写法都是类似的,不再过多介绍。其实,理解了聚合函数是迭代函数的简化形式这一个事实,能帮助理解为什么聚合函数只考虑筛选上下文而不考虑行上下文的原因。因为聚合函数是迭代函数的简化形式,而迭代函数的第一参数是在外部计值环境里计值的,所以聚合函数才只考虑筛选上下文而不考虑外部的行上下文。当然,如果采用了行上下文转换那就是另一回事了。

    三、FILTER详解

      在讲解FILTER之前,先给出FILTER的语法结构和作用:

    • FILTER
    FILTER ( <Table>, <FilterExpression> )
    

      迭代<Table>的所有可见数据并对<FilterExpression>计值,当计值结果为 TRUE,返回当前行;否则,就跳过当前行。


      FILTER的行为和上面介绍的迭代函数的行为是一样的,因为FILTER也是迭代函数,区别只在于,上面介绍的迭代函数的后续操作都是进行聚合,而FILTER的后续操作则是判断第一参数指定的表的可见数据是否需要保留。因此,上面介绍的迭代函数都是返回标量数值,而FILTER返回的则是一张表。

      可能有人会疑惑:FILTER仅仅只是行为特殊了点,为什么要拿出来单独讲。之所以将FILTER拿出来单独讲解,主要是因为迭代函数指定表的那个参数(一般为第一参数)不仅支持基础数据表而且还支持返回表的表达式,而FILTER的返回值就是一张表,因此可以将FILTER嵌套在FILTER的第一参数里。

      那么嵌套FILTER有什么好处呢?,首先, 嵌套FILTER的表达式的结果 与 在一个FILTER里使用AND或&&将条件连接起来所得到的结果是一样的,例如,下面两个表达式的结果就是一样的:

    FILTER ( <Table>, AND ( <condition1>, < condition2> ) )
    
    FILTER ( FILTER ( <Table>, < condition1> ), < condition2> )
    

      但是,虽然结果是相同的,可是上面两个表达式的执行顺序却是不同的,第一个FILTER的两个条件是同时进行判断的,而第二个FILTER是先执行内层的FILTER,所以是先判断<condition1>再判断<condition2> 。可千万别小看这个执行顺序的改变,虽然结果是一样的,但是改变执行顺序的同时也会改变表达式的性能,当你的数据量非常大的时候你是不得不考虑表达式的性能的。当然,若你的数据量较小那么自然是可以粗暴点的,能解决问题就完事了。

      通过利用嵌套FILTER的执行顺序不同这一特点,可以将约束性最强的筛选条件放到内层FILTER里先执行,因为约束性强就意味着判断的速度快!若筛选条件的约束性差异较大,却还是只是用一个FILTER,那么这些筛选条件都将同时判断,虽然约束性强的筛选条件判断完了,但还是需要等待其他筛选器进行判断,这性能自然就较差了。

      最后,下面有三个结果相同的表达式,你们可以判断一下哪个表达式的执行时间最快,结果就不告诉你们了,有兴趣的可以使用DAX Studio去测试,DAX表达式如下:

    CALCULATE(
        COUNTROWS('T3销售'),
        FILTER(ALL('T3销售'),
            'T3销售'[T3销售日期]>=DATE(2015,1,1)
                && 'T3销售'[T3销售日期]<=DATE(2016,12,31)
        )
    )
    
    CALCULATE(
        COUNTROWS('T3销售'),
        FILTER(
            FILTER(ALL('T3销售'),'T3销售'[T3销售日期]>=DATE(2015,1,1)),
            'T3销售'[T3销售日期]<=DATE(2016,12,31)
        )
    )
    
    CALCULATE(
        COUNTROWS('T3销售'),
        FILTER(ALL('T3销售'),'T3销售'[T3销售日期]>=DATE(2015,1,1)),
        FILTER(ALL('T3销售'), 'T3销售'[T3销售日期]<=DATE(2016,12,31))
    )
    

    四、总结

      虽然我在这篇文章中详细讲解了迭代函数的行为、语法结构以及注意事项等各种知识,并且还手动模拟了一个迭代函数的行为来帮助理解,但是想通过阅读就完全掌握一样东西几乎是不可能的。更何况,不同的迭代函数有不同的作用,且所支持的数据类型也有所不同。在这种情况下,想掌握好迭代函数就必须不断地去练习,去测试本文里提到的每一个注意事项!只有不断地练习,才能形成深刻的记忆!

    展开全文
  • 基于分形插值方法,构造了一类具有较大灵活性的分形插值迭代函数系。证明了这类迭代函数系的吸引子是经过给定插值点的分形插值曲线,并给出两个具体的例子,展示了此类分形插值曲线的形状。研究了这类分形插值函数关于...
  • 主要介绍了Python内建函数,可迭代对象,迭代器,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 函数方程和函数迭代问题.pdf
  • 主要讨论了可数无穷迭代函数系的分离性质。首先,考虑了非空紧子集X上的共形迭代函数系{Si}i∞=0,如果它满足有界畸变性质和弱分离条件,那么|Si(X)|→0。其次,研究了两类特殊的自相似无穷迭代函数系。其中一类中...
  • 迭代函数系统生成分形

    千次阅读 2017-12-06 00:53:38
    迭代函数系统(Iterated Function System,IFS)可以用来创建分形图案,他所创建的图形永远是自相似的。 有一个很著名的树叶图形的绘制便是使用了此原理。 在一个二维平面中,有4种映射函数,可以将一个...
    迭代函数系统(Iterated Function System,IFS)可以用来创建分形图案,他所创建的图形永远是自相似的。
    有一个很著名的树叶图形的绘制便是使用了此原理。

    在一个二维平面中,有4种映射函数,可以将一个点映射到另一个 位置:

    1.
        x(n+1)= 0
        y(n+1) = 0.16 * y(n)

    2.
        x(n+1) = 0.2 * x(n) − 0.26 * y(n)
        y(n+1) = 0.23 * x(n) + 0.22 * y(n) + 1.6

    3.
        x(n+1) = −0.15 * x(n) + 0.28 * y(n)
        y(n+1) = 0.26 * x(n) + 0.24 * y(n) + 0.44

    4.
        x(n+1) = 0.85 * x(n) + 0.04 * y(n)
        y(n+1) = −0.04 * x(n) + 0.85 * y(n) + 1.6


    可以看到,x(n+1)是x(n)和y(n)的函数,y(n+1)也是如此。即这一次的计算要使用到上一次的结果,因此称之为迭代。给定一个初始点 x(0),y(0),经过上面的映射函数的映射,便可以得到平面中许多点,这些点构成的图形便是分形图案。这个系统就叫做迭代函数系统。
    但是,一共有4个映射函数,我怎么知道每次迭代是要使用哪一个呢?
    因此,还需要给每个映射函数规定一个概率,按照概率来进行选择。

    源码如下,注释很详细:

    # 分形树叶
    import numpy as np
    import matplotlib.pyplot as pl
    import time

    # 蕨类植物叶子的迭代函数和概率
    eq1 = np.array([[0,0,0],[0,0.16,0]])
    p1 = 0.01
    eq2 = np.array([[0.2,-0.26,0],[0.23,0.22,1.6]])
    p2 = 0.07
    eq3 = np.array([[-0.15, 0.28, 0],[0.26,0.24,0.44]])
    p3 = 0.07
    eq4 = np.array([[0.85, 0.04, 0],[-0.04, 0.85, 1.6]])
    p4 = 0.85

    def ifs(p, eq, init, n):
        # 迭代向量的初始化
        pos = np.ones(3, dtype=np.float)
        pos[:2] = init # pos=[x,y,1]

        # 通过函数概率,计算函数的选择序列
        p = np.add.accumulate(p) # 累加,[p1,p1+p2,p1+p2+p3,...]
        rands = np.random.rand(n) # array,0~1的随机数,长度为10
        select = np.ones(n, dtype=np.int) # 想要得到的效果:select[i]=m表示第i个序列为m(0<=m<=len(p)-1)
        for i,x in enumerate(p[::-1]): # p[x:y:z]表示从x遍历到y,间隔为z。p[::-1]表示将前两个省略,间隔为-1,前两个默认为p[len(p)-1]到p[0]
            select[rands<x] = len(p)-i-1 # i=0时,x=p[len(p)-1]一定为1,因此第一步所有位置都赋为 len(p)-1。i=1时,x小于1,有一部分会满足rands<x。这一部分被赋值为 len(p)-2。这两次迭代的差集会永远被赋值为 len(p)-1不会变,则这个差集上的所有序列永远选择了第 len(p)-1 个迭代函数。

        # 结果的初始化
        result = np.zeros((n,2), dtype=np.float)
        c = np.zeros(n, dtype=np.float)

        for i in range(n):
            eqidx = select[i] # 所选函数的下标
            temp = np.dot(eq[eqidx], pos) # 迭代公式
            pos[:2] = temp # 更新迭代向量

            # 保存结果
            result[i] = temp # 第i次的结果:[x,y]
            c[i] = eqidx # 第i次的选择

        return result[:,0],result[:,1],c

    start = time.clock()
    x, y, c = ifs([p1,p2,p3,p4],[eq1,eq2,eq3,eq4], [0,0], 10000)
    print(time.clock() - start)
    pl.figure(figsize=(6,6))
    pl.subplot(121)
    pl.scatter(x, y, s=1, c="g", marker="s", linewidths=0) # s=1表示散列点大小为1,c="g"表示点的颜色为green,marker="s"表示点的形状为正方形(速度最快)
    pl.axis("equal")
    pl.axis("off")
    pl.subplot(122)
    pl.scatter(x, y, s=1,c = c, marker="s", linewidths=0) # c=c表示按照每次迭代选择的序列来作为颜色,方便知道四个函数产生的点的大概位置
    pl.axis("equal")
    pl.axis("off")
    pl.subplots_adjust(left=0,right=1,bottom=0,top=1,wspace=0,hspace=0)
    pl.gcf().patch.set_facecolor("white")
    pl.show()

    结果如下:


    叶子上的每一个枝叶,都与原叶形状相同。
    右图的蓝色枝干为1%的函数生成的点,蓝色和绿色的两个叶子是概率为7%的函数生成的点,剩下的黄色叶子为85的函数生成的点。

    实验一:
    以上是10万个点生成的图。如果改为1000个点,效果如下:

    可以看出:
    1、点的产生并不是从下而上累计的,而是每次都会有一定概率落在某个映射函数的结果集所在位置上,随着点数的增多,轮廓越来越明显和精细。
    2、当起始点定了之后,每一个映射函数都有自己的一个映射空间,不会超出这个空间。比如两个7%的函数的映射空间就是在蓝叶子和绿叶子的轮廓中,不会跳出这个范围。

    实验二:
    将起始点(0,0)改为不均衡的数,如(10,1),(-1,10)等。发现结果的形状相同。说明与起始点的值无关。这是因为,映射函数是坐标的线性变换,也是仿射变换,即不改变原有的直线性和平行性,只是进行翻转和伸缩。因此在同一个函数的作用下,两个不同位置的点进行的翻转动作是相同的,因此得到的结果形状也是相同的。

    展开全文
  • 通过计算机试验,对程序输出的结果和图形进行分析研究,以此探讨一次函数、二次函数迭代的一些性质。
  • 针对保形迭代函数的构造方法并不完整、不能快速地进行迭代运算的问题,本文给出了构造保形迭代函数的两个方法,一种是在已有方法基础上给出了快速迭代的算法;一种是构造特殊结构的保形函数.分析了他们的迭代效率并...
  • 主要介绍了python中的函数递归和迭代原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 当定义一个普通的类时,指向类的实例默认情况下是不可迭代的,如下 In [3]: from collections import Iterable In [4]: class Fruit(object): ...: def __init__(self): ...: self.i...
    1. 当定义一个普通的类时,指向类的实例默认情况下是不可迭代的,如下
    In [3]: from collections import Iterable                                        
    In [4]: class Fruit(object): 
       ...:     def __init__(self): 
       ...:         self.item = list() 
       ...:     def add(self,name): 
       ...:         self.item.append(name) 
       ...:                                                                         
    
    In [5]: list1 = Fruit()                                                        
    
    In [6]: isinstance(list1,Iterable)                                              
    Out[6]: False
    
    1. 因此在这种情况下,当对一个类的实例想要使用for…in…循环进行遍历时,便会报不可迭代的错误,为此要对函数进行改造,使其具有可迭代性,且能正确进行迭代操作,改造结果如下
    class Fruit():
        def __init__(self):
            self.item = list()
            # 为next函数计数器初始化
            self.count = 0
    
        def add(self,name):
            self.item.append(name)
    
    	# 使函数具有可迭代性
        def __iter__(self):
            return self
    
        def __next__(self):
        	# 获取下一个数
            if self.count < len(self.item):
                result = self.item[self.count]
                self.count += 1
                return result
            else:
            # 遍历结束后,抛出异常,终止遍历
                raise StopIteration
    
    
    list1 = Fruit()
    list1.add("apple")
    list1.add("banana")
    list1.add("orange")
    
    for item in list1:
        print(item)
    
    1. 下面详细解释,python在调用for…in…循环进行遍历时,对于类的实例的访问过程:
      ——检查该类是否具有迭代性,即调用类中的iter()方法
      —— 通过iter()函数获取类中的迭代器,通过调用迭代器中的next()方法,获取下一个值,并赋值给result
      ——遇到StopIteration的异常后循环结束
    2. 可将上段代码中对类的定义拆分成两个类来看,更加直观:
     class Fruit():
        def __init__(self):
            self.item = list()
    
        def add(self,name):
            self.item.append(name)
    
    	# 使函数具有可迭代性
        def __iter__(self):
            return myIterator(self)
    
    1. 以上是对Fruit类的定义,在其中定义iter()方法,使其具有可迭代性,通过iter()函数的返回值调用myIterator()迭代器;并对该迭代器传递一个self参数,使迭代器可以指向到自身。这部分代码使得类具有迭代性。
    class myIterator():
    
        def __init__(self,fru):
            self.fru = fru
            self.count = 0
    
        def __next__(self):
            if self.count < len(self.fru.item):
                result = self.fru.item[self.count]
                self.count += 1
                return result
            else:
                raise StopIteration
    
    1. 以上为Fruit类的迭代器通过参数fru的赋值,在迭代器中使self.fru变量指向Fruit类,从而在next函数中可以对Fruit类中的实例进行访问控制 。这部分代码完成了类的迭代器,保证可以调用next函数。
    展开全文
  • 最近在写RN相关的东西,其中涉及到了redux-saga ,saga的实现原理就是ES6中的Generator函数,而Generator函数又和迭代器有着密不可分的关系。所以本篇博客先学习总结了iterator相关的东西,然后又介绍了Generator...
  • 讨论了弱压缩无穷共形迭代函数系统及其Ruelle算子,利用Ruelle算子得到此迭代函数系统的Perron- Frobenius性质.
  • 策略迭代算法和值函数迭代算法

    千次阅读 2021-03-24 22:40:16
    策略迭代算法和值函数迭代算法 文章目录1. 回顾与引言2. 思路介绍3. 策略评估算法3. 策略优化算法4. 策略迭代算法和值函数迭代算法5. 代码实现6. 强化学习与最优控制 1. 回顾与引言 上一章中介绍了马尔科夫决策过程...
  • matlab开发-迭代复合函数TimeEscapeFractalExplorer。一个用于探索迭代复杂函数分形的图形用户界面。例如Julia Sets。
  • 迭代函数系统(IFS)

    千次阅读 2017-11-15 17:18:30
    迭代函数系统(IFS) IFS库源码已经上传GitHub fractal,需查看源码的请挪步。 自定义概率迭代函数 代码: # Sier三角变换 from fractal import IFS from random import randint def ifsp(x, y): p ...
  • Merkle-Damgrd(MD)迭代结构存在着不能保持压缩函数的第2原像稳固性、伪随机函数性等不安全性问题。为增强迭代哈希函数的安全性,从抵抗现有攻击的角度提出1个强化MD迭代结构,称为CMD结构。经证明,该结构可以保持...
  • 函数迭代函数的强大功能叫做迭代器,Python里面最具威力的功能之一。迭代器我们听起来会感觉非常陌生,在list、tuple都有用到它,我们是使用for和in取列表中的每一个元素,对每个元素依次处理,这种方法就叫做...
  • 基于离散余弦变换基函数迭代的人脸图像识别.pdf
  • Python:迭代函数系统(IFS)

    千次阅读 2018-12-26 11:10:56
    # -*- coding: utf-8 -*- import numpy as np import matplotlib.pyplot ...# 蕨类植物叶子的迭代函数和其概率值 eq1 = np.array([[0,0,0],[0,0.16,0]]) p1 = 0.01 eq2 = np.array([[0.2,-0.26,0],[0.23,0.22,1.6]...
  • 主要介绍了python 迭代器和iter()函数详解及实例的相关资料,需要的朋友可以参考下
  • 第4.3节 Python中与迭代相关的函数

    千次阅读 多人点赞 2019-05-06 18:17:31
    下面要介绍的enumerate、range、zip、reversed、sorted属于Python内置的函数或者类别,返回的对象都可通过迭代方法访问。 一、 enumerate函数 1. 语法:enumerate(iterable, start=0) 1) 该函数Python 2.3. 以上...
  • 第4讲函数迭代函数方程上.doc
  • 使用割线迭代方法查找函数根的代码。
  • 15、常用迭代函数详解

    千次阅读 2021-06-23 17:23:07
    本篇文章详细介绍了常用迭代函数的计值流程与细节
  • 3. 迭代器 3.1. 迭代器(Iterator)概述 ...对于原生支持随机访问的数据结构(如tuple、list),迭代器和经典for循环的索引访问相比并无优势,反而丢失了索引值(可以使用内建函数enumerate()找回这个索引值
  • 函数迭代是拓扑动力系统的重要研究对象.计算函数迭代往往是一件很困难的事,因此对迭代进行估计就变得相当重要.首先讨论了函数迭代估计的一个关系式,得到了函数迭代估计的一个更好的结果;然后研究了函数序列...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 721,640
精华内容 288,656
关键字:

对于迭代函数