精华内容
下载资源
问答
  • 在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑下实现功能,可以思考一下如果有某个功能的代码是在多个地方使用的是否可以只写一次?此时的代码该如何定义。先观察以下的案例: whileTrue:ifcpu...

    函数的基本概述

    在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,可以思考一下如果有某个功能的代码是在多个地方使用的是否可以只写一次?此时的代码该如何定义。先观察以下的案例:

    while True:
        if cpu利用率 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
        
        if 硬盘使用空间 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
        
        if 内存占用 > 80%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接

    以上代码中每个if条件语句下内容可以被提取出来公用 例:

    def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
        
    while True:
        
        if cpu利用率 > 90%:
            发送邮件('CPU报警')
        
        if 硬盘使用空间 > 90%:
            发送邮件('硬盘报警')
        
        if 内存占用 > 80%:
            发送邮件('内存报警')

    对于上述的两种实现方式,第二次必然比第一次的重用性和可读性要好,可以减少大量的代码量,减少开发时间,一处定义,多处调用,其实这就是函数式编程

    函数式编程的概念:
    开发程序时,需要某块代码多次使用,但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数

    函数的定义和调用

     

    <1>定义函数
      定义函数的格式如下:

        def 函数名():
          代码

      demo:

      # 定义一个函数,能够完成打印信息的功能
        def printInfo():
          print '------------------------------------'
          print ' 人生苦短,我用Python'
          print '------------------------------------'

     

    函数的定义主要有如下要点:

      • def:表示函数的关键字 • 函数名:函数的名称,调用时根据函数名调用函数
      • 函数体:函数中进行一系列的逻辑计算或是该函数的功能内容。
      • 参数:为函数体提供数据
      • 返回值:当函数执行完毕后,可以给调用者返回数据。

    <2>调用函数
    定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它(注意在定义函数时里面的内容不会执行)
    调用函数很简单的,通过 函数名() 即可完成调用

    demo:

      # 定义完函数后,函数是不会自动执行的,需要调用它才可以
      printInfo()


    <3>函数的文档说明
    例:
    >>> def test(a,b):
    ... "用来完成对2个数求和"
    ... print("%d"%(a+b))
    ... 
    >>> 
    >>> test(11,22)
    33
    执行,以下代码
    >>> help(test)

    能够看到test函数的相关说明

    ==============================================

    Help on function test in module __main__:

    test(a, b)
    用来完成对2个数求和
    (END)

     =============================================

     

    函数的参数-返回值

    <1> 定义带有参数的函数
      示例如下:
      def addnum(a, b):
        c = a+b
        print c
    <2> 调用带有参数的函数
      以调用上面的add2num(a, b)函数为例:

      def addnum(a, b):
        c = a+b
        print c

      add2num(11, 22) #调用带有参数的函数时,需要在小括号中,传递数据

      小总结:
      • 定义时小括号中的参数,用来接收参数用的,称为 “形参”
      • 调用时小括号中的参数,用来传递给函数用的,称为 “实参”

      ps:后面会有单独一篇详解函数参数的博客


    <3> 带有返回值的函数
      如下示例:
       def add2num(a, b):
        c = a+b
        return c
      
      保存函数的返回值示例如下:
      #定义函数


      def add2num(a, b):
        return a+b

       #调用函数,顺便保存函数的返回值
       result = add2num(100,98)

      #因为result已经保存了add2num的返回值,所以接下来就可以使用了
      print result
      结果:
      198


    在python中我们可以返回多个值
      >>> def divid(a, b):
      ... shang = a//b
      ... yushu = a%b 
      ... return shang, yushu
      ...
      >>> sh, yu = divid(5, 2)
      >>> sh
      5
      >>> yu
      1

    本质是利用了元组


    函数根据有没有参数,有没有返回值,可以相互组合,一共有4种
      • 无参数,无返回值
      • 无参数,无返回值
      • 有参数,无返回值
      • 有参数,有返回值


      <1>无参数,无返回值的函数
        此类函数,不能接收参数,也没有返回值,一般情况下,打印提示灯类似的功能,使用这类的函数
      <2>无参数,有返回值的函数
        此类函数,不能接收参数,但是可以返回某个数据,一般情况下,像采集数据,用此类函数
      <3>有参数,无返回值的函数
        此类函数,能接收参数,但不可以返回数据,一般情况下,对某些变量设置数据而不需结果时,用此类函数
      <4>有参数,有返回值的函数
        此类函数,不仅能接收参数,还可以返回某个数据,一般情况下,像数据处理并需要结果的应用,用此类函数
    小总结


          • 函数根据有没有参数,有没有返回值可以相互组合
      • 定义函数时,是根据实际的功能需求来设计的,所以不同开发人员编写的函数类型各不相同
      • 一个函数到底有没有返回值,就看有没有return,因为只有return才可以返回数据
      • 在开发中往往根据需求来设计函数需不需要返回值
      • 函数中,可以有多个return语句,但是只要执行到一个return语句,那么就意味着这个函数的调用完成
      • 一个程序当中函数的名字尽量不要重复,当函数名字重复时后面的会把前面的覆盖掉(注意:也不要与变量名重复同样会被覆盖)

    函数的嵌套

    def testB():
      print('---- testB start----')
      print('这里是testB函数执行的代码...(省略)...')
      print('---- testB end----')


    def testA():

      print('---- testA start----')

      testB()

      print('---- testA end----')

     

    调用

    testA()


    结果:
    ---- testA start----
    ---- testB start----
    这里是testB函数执行的代码...(省略)...
    ---- testB end----
    ---- testA end----

    小总结
      • 一个函数里面又调用了另外一个函数,这就是所谓的函数嵌套调用 
      • 如果函数A中,调用了另外一个函数B,那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

    函数嵌套的案例:

     

      1. 写一个函数求三个数的和
      2. 写一个函数求三个数的平均值


      # 求3个数的和
      def sum3Number(a,b,c):
        return a+b+c # return 的后面可以是数值,也可是一个表达式

     

      # 完成对3个数求平均值
      def average3Number(a,b,c):

        # 因为sum3Number函数已经完成了3个数的就和,所以只需调用即可
        # 即把接收到的3个数,当做实参传递即可
        sumResult = sum3Number(a,b,c)
        aveResult = sumResult/3.0
        return aveResult

     

      # 调用函数,完成对3个数求平均值

      result = average3Number(11,2,55)

      print("average is %d"%result)

    函数的局部变量、全局变量

    局部变量

      示例:
        In [8]: def text1():
        ...:     a = 200
        ...:     print("text1----%d" %a)
        ...:        print("修改后")
        ...:     a = 300
        ...:     print("text1----%d" %a)
        ...:

        In [9]: def text2():
        ...:    a = 400
        ...:        print("text2-----%d" %a)
        ...:

     

        In [10]: text1()
        text1----200
        修改后
        text1----300

        In [11]: text2()
        text2-----400

      总结
        • 局部变量,就是在函数内部定义的变量
        • 不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响
        • 局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

    全局变量

      概念:如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量

      

      示例:
        # 定义全局变量
        In [12]: a = 250

        In [13]: def text1():
        ...:      print("----text1----%d" %a)
        ...:

        In [14]: def text2():
        ...:      print("----text2----%d" %a)

        ...:

        In [15]: text1()
        ----text1----250

        In [16]: text2()
        ----text2----250

      

      当局部变量和全局变量重名的时候:
        In [23]: a = 250 # 全局变量

        In [24]: def text1():
        ...:     # 局部变量
        ...:      a = 521
        ...:      print("----text1----%d" %a)
        ...:      # 局部变量
        ...:      a = 666
        ...:      print("----text1----%d" %a)
        ...:

        In [25]: def text2():
        ...:     print("----text2----%d" %a)
        ...:

        In [26]: text1()
        ----text1----521
        ----text1----666

        In [27]: text2()
        ----text2----250

        In [28]:

        总结:
          • 在函数外边定义的变量叫做全局变量
          • 全局变量能够在所有的函数中进行访问
          • 如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的,小技巧强龙不压地头蛇

      在函数内部修改全局变量:
        In [31]: a = 250

        In [32]: def text1():
        ...:      a = 520
        ...:      print("----text1----%d" %a)

        In [33]:

        In [33]: def text2():
        ...:      global a
        ...:      a = 666
        ...:      print("----text2----%d" %a)
        ...:

        In [34]: # 没有调用任何函数

        In [35]: print(a)
        250

        In [36]: # 调用text1

        In [37]: text1()
        ----text1----520

        In [38]: # 再次打印---->

        In [39]: print(a)
        250

        In [40]: # 发现值并没有修改

        In [41]: # 调用text2

        In [42]: text2()
        ----text2----666

        In [43]: # 再次打印a

        In [44]: print(a)
        666

        In [45]: # 值已修改
        总结:
          • 如果在函数中修改全局变量,那么就需要使用global进行声明,否则相当于在(在没有传参数的情况)在函数内部重新定义了一个相同变量的对象

      对于 --可变类型的全局变量-和-不可变类型的全局变量-在函数内部修改的区别

        ps:后面会有博客详细说明可变类型与不可变类型的概念
        示例:------->不可变类型:
          In [46]: a = 6

          In [47]: def demo():
          ...:     a += 1
          ...:      print(a)
          ...:

          In [48]: demo()

          错误信息:
          ---------------------------------------------------------------------------
          UnboundLocalError Traceback (most recent call last)
          <ipython-input-48-00cf94af4371> in <module>()
          ----> 1 demo()

          <ipython-input-47-6e1d5ad81f64> in demo()
          1 def demo():
          ----> 2 a += 1
          3 print(a)
          4

          UnboundLocalError: local variable 'a' referenced before assignment

          --------------------------------------------------------------------------
          注:显然是不可以修改

         ------->可变类型:

          In [49]: a = [1,]

          In [50]:

          In [50]: def demo():
          ...:      a.append(2)
          ...:      print(a)
          ...:

          In [51]: demo()
          [1, 2]

          In [52]: a
          Out[52]: [1, 2]

          当调用函数时,在执行函数时在函数内部修改了列表的值--同时外部打印时也发生了变化。
      总结:

        ○ 如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错
        ○ 在函数中不使用global声明全局变量时不能修改全局变量的本质不能修改全局变量的指向不能将全局变量指向新的数据
        ○ 对于不可变类型的全局变量来说,因其指向的数据不能修改,所以不使用global时无法修改全局变量。
        ○ 对于可变类型的全局变量来说,因其指向的数据可以修改,所以不使用global时也可修改全局变量。

    转载于:https://www.cnblogs.com/kayb/p/7194006.html

    展开全文
  • 函数的基本概述在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑下实现功能,可以思考一下如果有某个功能的代码是在多个地方使用的是否可以只写一次?此时的代码该如何定义。先观察以下的案例:...

    函数的基本概述

    在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,可以思考一下如果有某个功能的代码是在多个地方使用的是否可以只写一次?此时的代码该如何定义。先观察以下的案例:

    while True:

    if cpu利用率 > 90%:

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

    if 硬盘使用空间 > 90%:

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

    if 内存占用 > 80%:

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

    以上代码中每个if条件语句下内容可以被提取出来公用 例:

    def 发送邮件(内容)

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

    while True:

    if cpu利用率 > 90%:

    发送邮件("CPU报警")

    if 硬盘使用空间 > 90%:

    发送邮件("硬盘报警")

    if 内存占用 > 80%:

    发送邮件("内存报警")

    对于上述的两种实现方式,第二次必然比第一次的重用性和可读性要好,可以减少大量的代码量,减少开发时间,一处定义,多处调用,其实这就是函数式编程

    函数式编程的概念:

    开发程序时,需要某块代码多次使用,但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数

    函数的定义和调用

    <1>定义函数

    定义函数的格式如下:

    def 函数名():

    代码

    demo:

    # 定义一个函数,能够完成打印信息的功能

    def printInfo():

    print "------------------------------------"

    print " 人生苦短,我用Python"

    print "------------------------------------"

    函数的定义主要有如下要点:

    • def:表示函数的关键字• 函数名:函数的名称,调用时根据函数名调用函数

    • 函数体:函数中进行一系列的逻辑计算或是该函数的功能内容。

    • 参数:为函数体提供数据

    • 返回值:当函数执行完毕后,可以给调用者返回数据。

    <2>调用函数

    定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它(注意在定义函数时里面的内容不会执行)

    调用函数很简单的,通过 函数名() 即可完成调用

    demo:

    # 定义完函数后,函数是不会自动执行的,需要调用它才可以

    printInfo()

    <3>函数的文档说明

    例:

    >>> def test(a,b):

    ... "用来完成对2个数求和"

    ... print("%d"%(a+b))

    ...

    >>>

    >>> test(11,22)

    33

    执行,以下代码

    >>> help(test)

    能够看到test函数的相关说明

    ==============================================

    Help on function test in module __main__:

    test(a, b)

    用来完成对2个数求和

    (END)

    =============================================

    函数的参数-返回值

    <1> 定义带有参数的函数

    示例如下:

    def addnum(a, b):

    c = a+b

    print c

    <2> 调用带有参数的函数

    以调用上面的add2num(a, b)函数为例:

    def addnum(a, b):

    c = a+b

    print c

    add2num(11, 22) #调用带有参数的函数时,需要在小括号中,传递数据

    小总结:

    • 定义时小括号中的参数,用来接收参数用的,称为 “形参”

    • 调用时小括号中的参数,用来传递给函数用的,称为 “实参”

    ps:后面会有单独一篇详解函数参数的博客

    <3> 带有返回值的函数

    如下示例:

    def add2num(a, b):

    c = a+b

    return c

    保存函数的返回值示例如下:

    #定义函数

    def add2num(a, b):

    return a+b

    #调用函数,顺便保存函数的返回值

    result = add2num(100,98)

    #因为result已经保存了add2num的返回值,所以接下来就可以使用了

    print result

    结果:

    198

    在python中我们可以返回多个值

    >>> def divid(a, b):

    ... shang = a//b

    ... yushu = a%b

    ... return shang, yushu

    ...

    >>> sh, yu = divid(5, 2)

    >>> sh

    5

    >>> yu

    1

    本质是利用了元组

    函数根据有没有参数,有没有返回值,可以相互组合,一共有4种

    • 无参数,无返回值

    • 无参数,无返回值

    • 有参数,无返回值

    • 有参数,有返回值

    <1>无参数,无返回值的函数

    此类函数,不能接收参数,也没有返回值,一般情况下,打印提示灯类似的功能,使用这类的函数

    <2>无参数,有返回值的函数

    此类函数,不能接收参数,但是可以返回某个数据,一般情况下,像采集数据,用此类函数

    <3>有参数,无返回值的函数

    此类函数,能接收参数,但不可以返回数据,一般情况下,对某些变量设置数据而不需结果时,用此类函数

    <4>有参数,有返回值的函数

    此类函数,不仅能接收参数,还可以返回某个数据,一般情况下,像数据处理并需要结果的应用,用此类函数

    小总结

    • 函数根据有没有参数,有没有返回值可以相互组合

    • 定义函数时,是根据实际的功能需求来设计的,所以不同开发人员编写的函数类型各不相同

    • 一个函数到底有没有返回值,就看有没有return,因为只有return才可以返回数据

    • 在开发中往往根据需求来设计函数需不需要返回值

    • 函数中,可以有多个return语句,但是只要执行到一个return语句,那么就意味着这个函数的调用完成

    •一个程序当中函数的名字尽量不要重复,当函数名字重复时后面的会把前面的覆盖掉(注意:也不要与变量名重复同样会被覆盖)

    函数的嵌套

    def testB():

    print("---- testB start----")

    print("这里是testB函数执行的代码...(省略)...")

    print("---- testB end----")

    def testA():

    print("---- testA start----")

    testB()

    print("---- testA end----")

    调用

    testA()

    结果:

    ---- testA start----

    ---- testB start----

    这里是testB函数执行的代码...(省略)...

    ---- testB end----

    ---- testA end----

    小总结:

    • 一个函数里面又调用了另外一个函数,这就是所谓的函数嵌套调用

    •如果函数A中,调用了另外一个函数B,那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

    函数嵌套的案例:

    1. 写一个函数求三个数的和

    2. 写一个函数求三个数的平均值

    # 求3个数的和

    def sum3Number(a,b,c):

    return a+b+c # return 的后面可以是数值,也可是一个表达式

    # 完成对3个数求平均值

    def average3Number(a,b,c):

    # 因为sum3Number函数已经完成了3个数的就和,所以只需调用即可

    # 即把接收到的3个数,当做实参传递即可

    sumResult = sum3Number(a,b,c)

    aveResult = sumResult/3.0

    return aveResult

    # 调用函数,完成对3个数求平均值

    result = average3Number(11,2,55)

    print("average is %d"%result)

    函数的局部变量、全局变量

    局部变量

    示例:

    In [8]: def text1():

    ...:     a = 200

    ...:     print("text1----%d" %a)

    ...:    print("修改后")

    ...:     a = 300

    ...:     print("text1----%d" %a)

    ...:

    In [9]: def text2():

    ...:    a = 400

    ...:    print("text2-----%d" %a)

    ...:

    In [10]: text1()

    text1----200

    修改后

    text1----300

    In [11]: text2()

    text2-----400

    总结

    • 局部变量,就是在函数内部定义的变量

    • 不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响

    • 局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

    全局变量

    概念:如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量

    示例:

    # 定义全局变量

    In [12]: a = 250

    In [13]: def text1():

    ...:      print("----text1----%d" %a)

    ...:

    In [14]: def text2():

    ...:      print("----text2----%d" %a)

    ...:

    In [15]: text1()

    ----text1----250

    In [16]: text2()

    ----text2----250

    当局部变量和全局变量重名的时候:

    In [23]: a = 250 # 全局变量

    In [24]: def text1():

    ...:    # 局部变量

    ...:      a = 521

    ...:      print("----text1----%d" %a)

    ...:    # 局部变量

    ...:      a = 666

    ...:      print("----text1----%d" %a)

    ...:

    In [25]: def text2():

    ...:     print("----text2----%d" %a)

    ...:

    In [26]: text1()

    ----text1----521

    ----text1----666

    In [27]: text2()

    ----text2----250

    In [28]:

    总结:

    • 在函数外边定义的变量叫做全局变量

    • 全局变量能够在所有的函数中进行访问

    • 如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的,小技巧强龙不压地头蛇

    在函数内部修改全局变量:

    In [31]: a = 250

    In [32]: def text1():

    ...:      a = 520

    ...:      print("----text1----%d" %a)

    In [33]:

    In [33]: def text2():

    ...:      global a

    ...:      a = 666

    ...:      print("----text2----%d" %a)

    ...:

    In [34]: # 没有调用任何函数

    In [35]: print(a)

    250

    In [36]: # 调用text1

    In [37]: text1()

    ----text1----520

    In [38]:# 再次打印---->

    In [39]: print(a)

    250

    In [40]: # 发现值并没有修改

    In [41]:# 调用text2

    In [42]: text2()

    ----text2----666

    In [43]:# 再次打印a

    In [44]: print(a)

    666

    In [45]:# 值已修改

    总结:

    • 如果在函数中修改全局变量,那么就需要使用global进行声明,否则相当于在(在没有传参数的情况)在函数内部重新定义了一个相同变量的对象

    对于 --可变类型的全局变量-和-不可变类型的全局变量-在函数内部修改的区别

    ps:后面会有博客详细说明可变类型与不可变类型的概念

    示例:------->不可变类型:

    In [46]: a = 6

    In [47]: def demo():

    ...:     a += 1

    ...:      print(a)

    ...:

    In [48]: demo()

    错误信息:

    ---------------------------------------------------------------------------

    UnboundLocalError Traceback (most recent call last)

    in ()

    ----> 1 demo()

    in demo()

    1 def demo():

    ----> 2 a += 1

    3 print(a)

    4

    UnboundLocalError: local variable "a" referenced before assignment

    --------------------------------------------------------------------------

    注:显然是不可以修改

    ------->可变类型:

    In [49]: a = [1,]

    In [50]:

    In [50]: def demo():

    ...:      a.append(2)

    ...:      print(a)

    ...:

    In [51]: demo()

    [1, 2]

    In [52]: a

    Out[52]: [1, 2]

    当调用函数时,在执行函数时在函数内部修改了列表的值--同时外部打印时也发生了变化。

    总结:

    ○ 如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错

    ○ 在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向,即不能将全局变量指向新的数据。

    ○ 对于不可变类型的全局变量来说,因其指向的数据不能修改,所以不使用global时无法修改全局变量。

    ○ 对于可变类型的全局变量来说,因其指向的数据可以修改,所以不使用global时也可修改全局变量。

    展开全文
  • 从局部变量声明的时候,它就在堆栈空间了,而不是调用函数的时候,才让它入栈的。 定义一个局部变量a,编译器会将a的地址分配寄存器组R0~R7中去。由于它是局部变量,所以编译器将使用立即数赋值语句为代表a的...

    局部变量空间,就是堆栈空间,也就是栈空间。

    从局部变量声明的时候,它就在堆栈空间了,而不是调用函数的时候,才让它入栈的。

    定义一个局部变量a,编译器会将a的地址分配到寄存器组R0~R7中去。由于它是局部变量,所以编译器将使用立即数赋值语句为代表a的寄存器Rn赋值,最后计算的结果也将存在寄存器组中,位置由编译器任意指定。

    定义一个全局变量a,编译器将在RAM中为变量a指定一个专用地址,在C程序中给a赋的值将存入这个专用地址中。程序操作变量a时,首先从专用地址中取出存放的值,然后再进行计算。

    结论:

    局部变量由于用寄存器直接操作,存取速度和计算速度都很快;由于寄存器数量有限,如果局部变量过多,将使代码由于频繁分配寄存器而变得冗长。

    全局变量被定义在内存中的专门地址上,存取位置固定。对于频繁存取的重要变量可以采用全局变量以减少代码的长度;由于全局变量总是占用内存,如果过多,或者把程序处理和计算中的一些中间变量也定义成全局变量,将大量消耗内存空间,处理速度会减慢,同时数据安全性也会降低。

    接触过编程的人都知道,高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢?程序又是如何使用这些变量的呢?下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明,默认都使用VC编译的release版。

    首先,来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local),静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码:

    include

    int g1=0, g2=0, g3=0;

    int main()

    {

    static int s1=0, s2=0, s3=0;

    int v1=0, v2=0, v3=0;

    //打印出各个变量的内存地址

    printf(“0xx\n”,&v1); //打印各本地变量的内存地址

    printf(“0xx\n”,&v2);

    printf(“0xx\n\n”,&v3);

    printf(“0xx\n”,&g1); //打印各全局变量的内存地址

    printf(“0xx\n”,&g2);

    printf(“0xx\n\n”,&g3);

    printf(“0xx\n”,&s1); //打印各静态变量的内存地址

    printf(“0xx\n”,&s2);

    printf(“0xx\n\n”,&s3);

    return 0;

    }

    编译后的执行结果是:

    0x0012ff78

    0x0012ff7c

    0x0012ff80

    0x004068d0

    0x004068d4

    0x004068d8

    0x004068dc

    0x004068e0

    0x004068e4

    输 出的结果就是变量的内存地址。其中v1,v2,v3是本地变量,g1,g2,g3是全局变量,s1,s2,s3是静态变量。你可以看到这些变量在内存是连 续分布的,但是本地变量和全局变量分配的内存地址差了十万八千里,而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不 同类型的内存区域中的结果。对于一个进程的内存空间而言,可以在逻辑上分成3个部份:代码区,静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈 (stack)”和“堆(heap)”是两种不同的动态数据区,栈是一种线性结构,堆是一种链式结构。进程的每个线程都有私有的“栈”,所以每个线程虽然 代码一样,但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区,本地变量分配在动态数 据区,即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。

    补充:怎么让程序的全局变量不会漫天飞

    1.使用结构体分类 
    2.把全局变量放在一个.c里面 
    3.如果外部函数要调用的话,就使用相应API(如cmSet_xxxxx() cmGet_xxxxx())

     

    源程序

    /*     名称:闪烁的LED
        说明:LED按设定的时间间隔闪烁
    */
    #include<reg51.h>
    #define uchar unsigned char
    #define uint unsigned int
    sbit LED=P1^0;
    //延时
    void DelayMS(uint x)
    {
        uchar i;
        while(x--)
        {
            for(i=0;i<120;i++);
        }
    }
    //主程序
    void main()
    {
        while(1)
        {
            LED=~LED;
            DelayMS(150);
        }
    }

    反汇编

        126: ?C_STARTUP:     LJMP    STARTUP1 
       127:  
       128:                 RSEG    ?C_C51STARTUP 
       129:  
       130: STARTUP1: 
       131:  
       132: IF IDATALEN <> 0 
    C:0x0000    020019   LJMP     STARTUP1(C:0019)
         9: void DelayMS(uint x) 
        10: { 
        11:         uchar i; 
        12:         while(x--) 
    C:0x0003    EF       MOV      A,R7
    C:0x0004    1F       DEC      R7
    C:0x0005    AA06     MOV      R2,0x06
    C:0x0007    7001     JNZ      C:000A
    C:0x0009    1E       DEC      R6
    C:0x000A    4A       ORL      A,R2
    C:0x000B    600B     JZ       C:0018
        13:         { 
        14:                 for(i=0;i<120;i++); 
    C:0x000D    E4       CLR      A
    C:0x000E    FD       MOV      R5,A
    C:0x000F    ED       MOV      A,R5
    C:0x0010    C3       CLR      C
    C:0x0011    9478     SUBB     A,#0x78
    C:0x0013    50EE     JNC      DelayMS(C:0003)
    C:0x0015    0D       INC      R5
    C:0x0016    80F7     SJMP     C:000F
        15:         } 
        16: } 
        17: //主程序 
    C:0x0018    22       RET      
       133:                 MOV     R0,#IDATALEN - 1 
    C:0x0019    787F     MOV      R0,#0x7F
       134:                 CLR     A 
    C:0x001B    E4       CLR      A
       135: IDATALOOP:      MOV     @R0,A 
    C:0x001C    F6       MOV      @R0,A
       136:                 DJNZ    R0,IDATALOOP 
    C:0x001D    D8FD     DJNZ     R0,IDATALOOP(C:001C)
       185:                 MOV     SP,#?STACK-1 
       186:  
       187: ; This code is required if you use L51_BANK.A51 with Banking Mode 4 
       188: ;<h> Code Banking 
       189: ; <q> Select Bank 0 for L51_BANK.A51 Mode 4 
       190: #if 0    
       191: ;     <i> Initialize bank mechanism to code bank 0 when using L51_BANK.A51 with Banking Mode 4. 
       192: EXTRN CODE (?B_SWITCH0) 
       193:                 CALL    ?B_SWITCH0      ; init bank mechanism to code bank 0 
       194: #endif 
       195: ;</h> 
    C:0x001F    758107   MOV      SP(0x81),#0x07
       196:                 LJMP    ?C_START 
    C:0x0022    020025   LJMP     main(C:0025)
        18: void main() 
        19: { 
        20:         while(1) 
        21:         { 
        22:                 LED=~LED; 
    C:0x0025    B290     CPL      LED(0x90.0)
        23:                 DelayMS(150); 
    C:0x0027    7F96     MOV      R7,#0x96
    C:0x0029    7E00     MOV      R6,#0x00
    C:0x002B    120003   LCALL    DelayMS(C:0003)
        24:         } 
    C:0x002E    80F5     SJMP     main(C:0025)
    C:0x0030    00       NOP      
    C:0x0031    00       NOP      

     

     

    展开全文
  • 我们继续对辛双级流形进行兼容的推导,探讨局部双场理论(DFT),并研究了杂散DFT的情况。 我们详细开发微分渐变流形开始,该流形捕获了异质广义... 最后,我们展示了如何在我们的框架中自然地解释观察到的α'校正。
  • 全局变量和局部变量 类型属性 属性将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分,而计算属性计算(不是存储)一个值。计算属性可以用于类、结构体和枚举,存储属性只能用于类和结构体。...

    本节内容转载于
    http://www.swift51.com/swift4.0/chapter2/10_Properties.html

    本页包含内容:

    存储属性
    计算属性
    属性观察器
    全局变量和局部变量
    类型属性
    属性将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分,而计算属性计算(不是存储)一个值。计算属性可以用于类、结构体和枚举,存储属性只能用于类和结构体。

    存储属性和计算属性通常与特定类型的实例关联。但是,属性也可以直接作用于类型本身,这种属性称为类型属性。

    另外,还可以定义属性观察器来监控属性值的变化,以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上,也可以添加到从父类继承的属性上。

    存储属性
    简单来说,一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。存储属性可以是变量存储属性(用关键字 var 定义),也可以是常量存储属性(用关键字 let 定义)。

    可以在定义存储属性的时候指定默认值,请参考默认构造器一节。也可以在构造过程中设置或修改存储属性的值,甚至修改常量存储属性的值,请参考构造过程中常量属性的修改一节。

    下面的例子定义了一个名为 FixedLengthRange 的结构体,该结构体用于描述整数的范围,且这个范围值在被创建后不能被修改.

    struct FixedLengthRange {
    var firstValue: Int
    let length: Int
    }
    var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
    // 该区间表示整数0,1,2
    rangeOfThreeItems.firstValue = 6
    // 该区间现在表示整数6,7,8
    FixedLengthRange 的实例包含一个名为 firstValue 的变量存储属性和一个名为 length 的常量存储属性。在上面的例子中,length 在创建实例的时候被初始化,因为它是一个常量存储属性,所以之后无法修改它的值。

    常量结构体的存储属性
    如果创建了一个结构体的实例并将其赋值给一个常量,则无法修改该实例的任何属性,即使有属性被声明为变量也不行:

    let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
    // 该区间表示整数0,1,2,3
    rangeOfFourItems.firstValue = 6
    // 尽管 firstValue 是个变量属性,这里还是会报错
    因为 rangeOfFourItems 被声明成了常量(用 let 关键字),即使 firstValue 是一个变量属性,也无法再修改它了。

    这种行为是由于结构体(struct)属于值类型。当值类型的实例被声明为常量的时候,它的所有属性也就成了常量。

    属于引用类型的类(class)则不一样。把一个引用类型的实例赋给一个常量后,仍然可以修改该实例的变量属性。

    延迟存储属性
    延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 lazy 来标示一个延迟存储属性。

    注意
    必须将延迟存储属性声明成变量(使用 var 关键字),因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值,因此无法声明成延迟属性。

    延迟属性很有用,当属性的值依赖于在实例的构造过程结束后才会知道影响值的外部因素时,或者当获得属性的初始值需要复杂或大量计算时,可以只在需要的时候计算它。

    下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了 DataImporter 和 DataManager 两个类,下面是部分代码:

    class DataImporter {
    /* DataImporter 是一个负责将外部文件中的数据导入的类。 这个类的初始化会消耗不少时间。 */
    var fileName = “data.txt”
    // 这里会提供数据导入功能
    }

    class DataManager {
    lazy var importer = DataImporter()
    var data = String
    // 这里会提供数据管理功能
    }

    let manager = DataManager()
    manager.data.append(“Some data”)
    manager.data.append(“Some more data”)
    // DataImporter 实例的 importer 属性还没有被创建
    DataManager 类包含一个名为 data 的存储属性,初始值是一个空的字符串(String)数组。这里没有给出全部代码,只需知道 DataManager 类的目的是管理和提供对这个字符串数组的访问即可。

    DataManager 的一个功能是从文件导入数据。该功能由 DataImporter 类提供,DataImporter 完成初始化需要消耗不少时间:因为它的实例在初始化时可能要打开文件,还要读取文件内容到内存。

    DataManager 管理数据时也可能不从文件中导入数据。所以当 DataManager 的实例被创建时,没必要创建一个 DataImporter 的实例,更明智的做法是第一次用到 DataImporter 的时候才去创建它。

    由于使用了 lazy ,importer 属性只有在第一次被访问的时候才被创建。比如访问它的属性 fileName 时:

    print(manager.importer.fileName)
    // DataImporter 实例的 importer 属性现在被创建了
    // 输出 "data.txt”
    注意
    如果一个被标记为 lazy 的属性在没有初始化时就同时被多个线程访问,则无法保证该属性只会被初始化一次。

    存储属性和实例变量
    如果您有过 Objective-C 经验,应该知道 Objective-C 为类实例存储值和引用提供两种方法。除了属性之外,还可以使用实例变量作为属性值的后端存储。

    Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量,属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰,同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方(类型定义中)定义。

    计算属性
    除存储属性外,类、结构体和枚举可以定义计算属性。计算属性不直接存储值,而是提供一个 getter 和一个可选的 setter,来间接获取和设置其他属性或变量的值。

    struct Point {
    var x = 0.0, y = 0.0
    }
    struct Size {
    var width = 0.0, height = 0.0
    }
    struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
    get {
    let centerX = origin.x + (size.width / 2)
    let centerY = origin.y + (size.height / 2)
    return Point(x: centerX, y: centerY)
    }
    set(newCenter) {
    origin.x = newCenter.x - (size.width / 2)
    origin.y = newCenter.y - (size.height / 2)
    }
    }
    }
    var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))
    let initialSquareCenter = square.center
    square.center = Point(x: 15.0, y: 15.0)
    print(“square.origin is now at ((square.origin.x), (square.origin.y))”)
    // 打印 "square.origin is now at (10.0, 10.0)”
    这个例子定义了 3 个结构体来描述几何形状:

    Point 封装了一个 (x, y) 的坐标
    Size 封装了一个 width 和一个 height
    Rect 表示一个有原点和尺寸的矩形
    Rect也提供了一个名为center 的计算属性。一个矩形的中心点可以从原点(origin)和大小(size)算出,所以不需要将它以显式声明的 Point 来保存。Rect 的计算属性 center 提供了自定义的 getter 和 setter 来获取和设置矩形的中心点,就像它有一个存储属性一样。

    上述例子中创建了一个名为 square 的 Rect 实例,初始值原点是 (0, 0),宽度高度都是 10。如下图中蓝色正方形所示。

    square 的 center 属性可以通过点运算符(square.center)来访问,这会调用该属性的 getter 来获取它的值。跟直接返回已经存在的值不同,getter 实际上通过计算然后返回一个新的 Point 来表示 square 的中心点。如代码所示,它正确返回了中心点 (5, 5)。

    center 属性之后被设置了一个新的值 (15, 15),表示向右上方移动正方形到如下图橙色正方形所示的位置。设置属性center的值会调用它的 setter 来修改属性 origin 的 x 和 y 的值,从而实现移动正方形到新的位置。

    Computed Properties sample

    简化 setter 声明
    如果计算属性的 setter 没有定义表示新值的参数名,则可以使用默认名称 newValue。下面是使用了简化 setter 声明的 Rect 结构体代码:

    struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
    get {
    let centerX = origin.x + (size.width / 2)
    let centerY = origin.y + (size.height / 2)
    return Point(x: centerX, y: centerY)
    }
    set {
    origin.x = newValue.x - (size.width / 2)
    origin.y = newValue.y - (size.height / 2)
    }
    }
    }

    只读计算属性
    只有 getter 没有 setter 的计算属性就是只读计算属性。只读计算属性总是返回一个值,可以通过点运算符访问,但不能设置新的值。

    注意
    必须使用 var 关键字定义计算属性,包括只读计算属性,因为它们的值不是固定的。let 关键字只用来声明常量属性,表示初始化后再也无法修改的值。

    只读计算属性的声明可以去掉 get 关键字和花括号:

    struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
    return width * height * depth
    }
    }
    let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
    print(“the volume of fourByFiveByTwo is (fourByFiveByTwo.volume)”)
    // 打印 “the volume of fourByFiveByTwo is 40.0”
    这个例子定义了一个名为 Cuboid 的结构体,表示三维空间的立方体,包含 width、height 和 depth 属性。结构体还有一个名为 volume 的只读计算属性用来返回立方体的体积。为 volume 提供 setter 毫无意义,因为无法确定如何修改 width、height 和 depth 三者的值来匹配新的 volume。然而,Cuboid 提供一个只读计算属性来让外部用户直接获取体积是很有用的。

    属性观察器
    属性观察器监控和响应属性值的变化,每次属性被设置值的时候都会调用属性观察器,即使新值和当前值相同的时候也不例外。

    可以为除了延迟存储属性之外的其他存储属性添加属性观察器,也可以通过重写属性的方式为继承的属性(包括存储属性和计算属性)添加属性观察器。你不必为非重写的计算属性添加属性观察器,因为可以通过它的 setter 直接监控和响应值的变化。 属性重写请参考重写。

    可以为属性添加如下的一个或全部观察器:

    willSet 在新的值被设置之前调用
    didSet 在新的值被设置之后立即调用
    willSet 观察器会将新的属性值作为常量参数传入,在 willSet 的实现代码中可以为这个参数指定一个名称,如果不指定则参数仍然可用,这时使用默认名称 newValue 表示。

    同样,didSet 观察器会将旧的属性值作为参数传入,可以为该参数命名或者使用默认参数名 oldValue。如果在 didSet 方法中再次对该属性赋值,那么新值会覆盖旧的值。

    注意
    父类的属性在子类的构造器中被赋值时,它在父类中的 willSet 和 didSet 观察器会被调用,随后才会调用子类的观察器。在父类初始化方法调用之前,子类给属性赋值时,观察器不会被调用。 有关构造器代理的更多信息,请参考值类型的构造器代理和类的构造器代理规则。

    下面是一个 willSet 和 didSet 实际运用的例子,其中定义了一个名为 StepCounter 的类,用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。

    class StepCounter {
    var totalSteps: Int = 0 {
    willSet(newTotalSteps) {
    print(“About to set totalSteps to (newTotalSteps)”)
    }
    didSet {
    if totalSteps > oldValue {
    print(“Added (totalSteps - oldValue) steps”)
    }
    }
    }
    }
    let stepCounter = StepCounter()
    stepCounter.totalSteps = 200
    // About to set totalSteps to 200
    // Added 200 steps
    stepCounter.totalSteps = 360
    // About to set totalSteps to 360
    // Added 160 steps
    stepCounter.totalSteps = 896
    // About to set totalSteps to 896
    // Added 536 steps
    StepCounter 类定义了一个 Int 类型的属性 totalSteps,它是一个存储属性,包含 willSet 和 didSet 观察器。

    当 totalSteps 被设置新值的时候,它的 willSet 和 didSet 观察器都会被调用,即使新值和当前值完全相同时也会被调用。

    例子中的 willSet 观察器将表示新值的参数自定义为 newTotalSteps,这个观察器只是简单的将新的值输出。

    didSet 观察器在 totalSteps 的值改变后被调用,它把新值和旧值进行对比,如果总步数增加了,就输出一个消息表示增加了多少步。didSet 没有为旧值提供自定义名称,所以默认值 oldValue 表示旧值的参数名。

    注意

    如果将属性通过 in-out 方式传入函数,willSet 和 didSet 也会调用。这是因为 in-out 参数采用了拷入拷出模式:即在函数内部使用的是参数的 copy,函数结束后,又对参数重新赋值。关于 in-out 参数详细的介绍,请参考输入输出参数

    全局变量和局部变量
    计算属性和属性观察器所描述的功能也可以用于全局变量和局部变量。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。

    前面章节提到的全局或局部变量都属于存储型变量,跟存储属性类似,它为特定类型的值提供存储空间,并允许读取和写入。

    另外,在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样,返回一个计算结果而不是存储值,声明格式也完全一样。

    注意
    全局的常量或变量都是延迟计算的,跟延迟存储属性相似,不同的地方在于,全局的常量或变量不需要标记lazy修饰符。
    局部范围的常量或变量从不延迟计算。

    类型属性
    实例属性属于一个特定类型的实例,每创建一个实例,实例都拥有属于自己的一套属性值,实例之间的属性相互独立。

    也可以为类型本身定义属性,无论创建了多少个该类型的实例,这些属性都只有唯一一份。这种属性就是类型属性。

    类型属性用于定义某个类型所有实例共享的数据,比如所有实例都能用的一个常量(就像 C 语言中的静态常量),或者所有实例都能访问的一个变量(就像 C 语言中的静态变量)。

    存储型类型属性可以是变量或常量,计算型类型属性跟实例的计算型属性一样只能定义成变量属性。

    注意
    跟实例的存储型属性不同,必须给存储型类型属性指定默认值,因为类型本身没有构造器,也就无法在初始化过程中使用构造器给类型属性赋值。
    存储型类型属性是延迟初始化的,它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问,系统也保证只会对其进行一次初始化,并且不需要对其使用 lazy 修饰符。

    类型属性语法
    在 C 或 Objective-C 中,与某个类型关联的静态常量和静态变量,是作为全局(global)静态变量定义的。但是在 Swift 中,类型属性是作为类型定义的一部分写在类型最外层的花括号内,因此它的作用范围也就在类型支持的范围内。

    使用关键字 static 来定义类型属性。在为类定义计算型类型属性时,可以改用关键字 class 来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法:

    struct SomeStructure {
    static var storedTypeProperty = “Some value.”
    static var computedTypeProperty: Int {
    return 1
    }
    }
    enum SomeEnumeration {
    static var storedTypeProperty = “Some value.”
    static var computedTypeProperty: Int {
    return 6
    }
    }
    class SomeClass {
    static var storedTypeProperty = “Some value.”
    static var computedTypeProperty: Int {
    return 27
    }
    class var overrideableComputedTypeProperty: Int {
    return 107
    }
    }
    注意
    例子中的计算型类型属性是只读的,但也可以定义可读可写的计算型类型属性,跟计算型实例属性的语法相同。

    获取和设置类型属性的值
    跟实例属性一样,类型属性也是通过点运算符来访问。但是,类型属性是通过类型本身来访问,而不是通过实例。比如:

    print(SomeStructure.storedTypeProperty)
    // 打印 “Some value.”
    SomeStructure.storedTypeProperty = “Another value.”
    print(SomeStructure.storedTypeProperty)
    // 打印 "Another value.”
    print(SomeEnumeration.computedTypeProperty)
    // 打印 “6”
    print(SomeClass.computedTypeProperty)
    // 打印 “27”
    下面的例子定义了一个结构体,使用两个存储型类型属性来表示两个声道的音量,每个声道具有 0 到 10 之间的整数音量。

    下图展示了如何把两个声道结合来模拟立体声的音量。当声道的音量是 0,没有一个灯会亮;当声道的音量是 10,所有灯点亮。本图中,左声道的音量是 9,右声道的音量是 7:

    Static Properties VUMeter

    上面所描述的声道模型使用 AudioChannel 结构体的实例来表示:

    struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
    didSet {
    if currentLevel > AudioChannel.thresholdLevel {
    // 将当前音量限制在阈值之内
    currentLevel = AudioChannel.thresholdLevel
    }
    if currentLevel > AudioChannel.maxInputLevelForAllChannels {
    // 存储当前音量作为新的最大输入音量
    AudioChannel.maxInputLevelForAllChannels = currentLevel
    }
    }
    }
    }
    结构 AudioChannel 定义了 2 个存储型类型属性来实现上述功能。第一个是 thresholdLevel,表示音量的最大上限阈值,它是一个值为 10 的常量,对所有实例都可见,如果音量高于 10,则取最大上限值 10(见后面描述)。

    第二个类型属性是变量存储型属性 maxInputLevelForAllChannels,它用来表示所有 AudioChannel 实例的最大音量,初始值是0。

    AudioChannel 也定义了一个名为 currentLevel 的存储型实例属性,表示当前声道现在的音量,取值为 0 到 10。

    属性 currentLevel 包含 didSet 属性观察器来检查每次设置后的属性值,它做如下两个检查:

    如果 currentLevel 的新值大于允许的阈值 thresholdLevel,属性观察器将 currentLevel 的值限定为阈值 thresholdLevel。
    如果修正后的 currentLevel 值大于静态类型属性 maxInputLevelForAllChannels 的值,属性观察器就将新值保存在 maxInputLevelForAllChannels 中。
    注意
    在第一个检查过程中,didSet 属性观察器将 currentLevel 设置成了不同的值,但这不会造成属性观察器被再次调用。

    可以使用结构体 AudioChannel 创建两个声道 leftChannel 和 rightChannel,用以表示立体声系统的音量:

    var leftChannel = AudioChannel()
    var rightChannel = AudioChannel()
    如果将左声道的 currentLevel 设置成 7,类型属性 maxInputLevelForAllChannels 也会更新成 7:

    leftChannel.currentLevel = 7
    print(leftChannel.currentLevel)
    // 输出 “7”
    print(AudioChannel.maxInputLevelForAllChannels)
    // 输出 “7”
    如果试图将右声道的 currentLevel 设置成 11,它会被修正到最大值 10,同时 maxInputLevelForAllChannels 的值也会更新到 10:

    rightChannel.currentLevel = 11
    print(rightChannel.currentLevel)
    // 输出 “10”
    print(AudioChannel.maxInputLevelForAllChannels)
    // 输出 “10”

    展开全文
  • 观察兴奋的Bc +状态

    2020-04-20 07:16:17
    观察到的峰的质量为6841.2±0.6(stat)±0.1(syst)±0.8(Bc +)MeV / c2,其中最后一个不确定度是由于对Bc +质量的了解有限。 这与在没有低能量光子的情况下Bc *(1S31)+→Bc +γ随Bc *(2S31)+→Bc *(1S...
  • ConvBERT 阅读笔记

    2020-10-13 10:23:24
    虽然BERT的从全局产生了注意力map,我们观察到一些 注意力头 只需要学到局部的依赖即可,也就是BERT存在冗余。 于是我们提出 基于区间的动态卷积 来替换 自注意力头 来 直接建模局部依赖。 ConvBERT-BASE模型在GLUE...
  •  局部所以等同于为每个分区段建分区索引,user_segment的数据字典中,我们可以观察到表有多少个分区,就有多少个分区索引的segment.  先建分区表来测试 create table part_tab(id int,col2 in
  • 局部坐标 是对象相对于局部原点的...接下来我们将世界坐标变换为 观察空间坐标,使得每个坐标都是摄像机或者说观察者的角度进行观察的。 坐标到达观察空间之后,我们需要将其投影 裁剪坐标。裁剪坐标会被处理至...
  • OpenGL(六)坐标系统

    2018-08-28 19:03:04
    (一)为了将坐标一个坐标系变换另一个坐标系,我们需要用到几个变换矩阵,最重要的几个分别是模型、观察、投影三个矩阵。 局部坐标:相对于局部原点的坐标,也是物体起始的坐标。 世界坐标:下一步是将局部...
  • web4(css3)

    2020-02-20 23:33:31
    2、按照从外到内,从全局到局部的顺序分析每一行 3、每做一级,都要设置样式,并观察好位置是否正确。 注意: 在行布局时,要注意,尽可能的留下空隙(弹性空间)在需要大范围的自适应时,我们通常会将最后一个容器...
  • 这题一眼有点像最小路径覆盖(二分图or网络流),但实际上并不一样,因为全局最优与局部最优可能会有冲突 实际上观察这题的数据,推测复杂度O(n)O(n) 不难想到选取的II条路径都是叶子叶子存在...
  • 应注意的是,很多人认为梯度反方向是下降最快的,这种说法和理解是片面的,不准确的,它只是局部最快,而不是全局最快,因此我们可以观察到,很多机器学习算法常会陷于局部最优,例如BP神经网络算法。要理解梯度,...
  • IAR 条件断点

    2017-03-13 10:00:00
    条件断点是IDE的一个重要功能,在IAR调试时候,经常跟踪一个数据,但是对较大的buffer,...二是由于数据结构太大,一旦加watch里面,如果全局观察,大多数情况会很慢,并且极容易一点开折叠就发生软件崩溃。 两个...
  • 首先明白setState,相当于触发刷新,全局的,我们也可以局部刷新,类似用到订阅者观察者思想的provider。如果是写mvvm的应该会很明白,写mvc,mvp的可能会很别扭,状态已经预先根据模型判断好了,这个在我没写mvvm...
  • 模拟退火算法

    2019-06-24 14:28:35
    某一较高的温度出发,这个温度称为初始温度,伴随着温度参数的不断下降,算法中的解趋于稳定,但是,可能这样的稳定解是一个局部最优解,此时,模拟退火算法中会以一定的概率跳出这样的局部最优解,以寻找目标函数...
  • 对像图案然后使用子模式表示,连同空间关系的子模式中观察到的。许多特征描述符可以被用来描述这些子patterns.The NAM模型码对像类别的全局几何形状,并与对像的局部变化子模式处理的局部特征描述符。通过使用边缘...
  • 过去现在将来

    2019-10-10 19:29:00
    即使有些事物看似不断循环发展的也是在循环中不断迭代演变就像车轮在前行一样,不应该只盯着车轮(局部)而应该观察整体的(全局) 例如,中国历史部落联盟时代(尧舜禹夏)邦国时代(商周)再帝国时代(秦...
  • 极限上升到1.1,这可能是由于存在Drell–Yan双电子产生,在这种情况下电子可能被误认为是孤立的光子 ,以及第二个是由于相对于标准模型预测而言观察到的过量,对于质量假设95.3 GeV具有局部全局)有效值2.8(1.3)...
  • 然后,我们观察到对Q云的研究是一种通用工具,可用于给定的秃头BH建立具有同步头发分叉(全局局部)的BH的存在,而不必解决爱因斯坦问题的完全非线性耦合系统 方程。 例如,我们使用此工具在D = 6 Myers-Perry ...
  • 对话图-源码

    2021-02-13 13:18:39
    通过将巡视链接到从NLDR方法获得的视图,我们可以保留全局结构,并通过用户交互(如链接的笔刷)观察NLDR视图可能会误导的地方。 我们展示了一些用例来说明我们的方法。 幻灯片 带回家的消息 面向灾难的工作流程...
  • S 4球在E 5上的刚性平移使经典作用不变,但S 4上的重力动力学的角度来看是不可观察到的位移。 因此,与类似的模量不同,球的中心不会提升到动态自由度。 结果,这些零模式并不表示可能对dS空间的度量进行物理实现...
  • 函数寻优是工程中经常遇到的问题,有些函数因为局部极小值点的存在,算法难以寻找到局部最优值。粒子群算 法具有群体智能,全局寻优等优势,比较适合于函数寻优问题,本案例研究了基于粒子群算法的函数寻优算法。 ...
  • javascript入门笔记

    2018-05-15 15:01:07
    赋值符号出现的话,永远都是将右边的值,赋值给左边的变量(右向左运算) 2、常量 1、什么是常量 在程序中,一旦声明好,就不允许被修改的数据 2、声明常量 const 常量名=值; 常量名在命名时采用全大写形式 ...
  • 收获不知Oracle

    2018-08-07 14:23:17
    2.3.2 单车飞船的经典之旅 70 2.3.2.1 未优化前,单车速度 70 2.3.2.2 绑定变量,摩托速度 72 2.3.2.3 静态改写,汽车速度 74 2.3.2.4 批量提交,动车速度 75 2.3.2.5 集合写法,飞机速度 77 2.3.2.6 直接路径,...
  • php高级开发教程说明

    2008-11-27 11:39:22
    能够快速地一点转另一点—但其他人可能认为这并不容易。如果你开发组的某个人手 中获得一个源文件并需要添加一些特征,首先必须对其进行整体把握,并区分代码的各个部分。 理想情况下,这一过程将和阅读源文件...
  • LINGO软件的学习

    2009-08-08 22:36:50
    因此,派生集的索引个数是最终原始父集的个数,索引的取值是原始父集当前派生集所作限制的总和。 总的来说,LINGO可识别的集只有两种类型:原始集和派生集。 在一个模型中,原始集是基本的对象,不能再被拆分成...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

从全局观察到局部