精华内容
下载资源
问答
  • 8)变量或者函数名拼写错误(导致“NameError: name 'fooba' is not defined”) 该错误发生在如下代码中: 9)方法名拼写错误(导致 “AttributeError: 'str' object has no attribute 'lowerr'”) 该错误发生在如下...

    当初学 Python 时,想要弄懂 Python 的错误信息的含义可能有点复杂。这里列出了常见的的一些让你程序 crash 的运行时错误。

    1)忘记在if,elif,else,for,while,class,def声明末尾添加 :(导致 “SyntaxError :invalid syntax”)

    该错误将发生在类似如下代码中:

    2)使用 = 而不是 ==(导致“SyntaxError: invalid syntax”)

    = 是赋值操作符而 == 是等于比较操作。该错误发生在如下代码中:

    3)错误的使用缩进量。(导致“IndentationError:unexpected indent”、“IndentationError:unindent does not match any outer indetation level”以及“IndentationError:expected an indented block”)

    记住缩进增加只用在以:结束的语句之后,而之后必须恢复到之前的缩进格式。该错误发生在如下代码中:

    4)在for循环语句中忘记调用len()(导致“TypeError: 'list' object cannot be interpreted as an integer”)

    通常你想要通过索引来迭代一个list或者string的元素,这需要调用range()函数。要记得返回len值而不是返回这个列表。

    该错误发生在如下代码中:

    5)尝试修改string的值(导致“TypeError: 'str' object does not support item assignment”)

    string是一种不可变的数据类型,该错误发生在如下代码中:

    而你实际想要这样做:

    6)尝试连接非字符串值与字符串(导致 “TypeError: Can't convert 'int' object to str implicitly”)

    该错误发生在如下代码中:

    而你实际想要这样做:

    7)在字符串首尾忘记加引号(导致“SyntaxError: EOL while scanning string literal”)

    该错误发生在如下代码中:

    8)变量或者函数名拼写错误(导致“NameError: name 'fooba' is not defined”)

    该错误发生在如下代码中:

    9)方法名拼写错误(导致 “AttributeError: 'str' object has no attribute 'lowerr'”)

    该错误发生在如下代码中:

    10)引用超过list最大索引(导致“IndexError: list index out of range”)

    该错误发生在如下代码中:

    11)使用不存在的字典键值(导致“KeyError:‘spam’”)

    该错误发生在如下代码中:

    12)尝试使用Python关键字作为变量名(导致“SyntaxError:invalid syntax”)

    Python关键不能用作变量名,该错误发生在如下代码中:

    Python3的关键字有:and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield

    13)在一个定义新变量中使用增值操作符(导致“NameError: name 'foobar' is not defined”)

    不要在声明变量时使用0或者空字符串作为初始值,这样使用自增操作符的一句spam += 1等于spam = spam + 1,这意味着spam需要指定一个有效的初始值。

    该错误发生在如下代码中:

    14)在定义局部变量前在函数中使用局部变量(此时有与局部变量同名的全局变量存在)(导致“UnboundLocalError: local variable 'foobar' referenced before assignment”)

    在函数中使用局部变来那个而同时又存在同名全局变量时是很复杂的,使用规则是:如果在函数中定义了任何东西,如果它只是在函数中使用那它就是局部的,反之就是全局变量。

    这意味着你不能在定义它之前把它当全局变量在函数中使用。

    该错误发生在如下代码中:

    15)尝试使用 range()创建整数列表(导致“TypeError: 'range' object does not support item assignment”)

    有时你想要得到一个有序的整数列表,所以 range() 看上去是生成此列表的不错方式。然而,你需要记住 range() 返回的是 “range object”,而不是实际的 list 值。

    该错误发生在如下代码中:

    也许这才是你想做:

    (注意:在 Python 2 中 spam = range(10) 是能行的,因为在 Python 2 中 range() 返回的是list值,但是在 Python 3 中就会产生以上错误)

    16)不错在 ++ 或者 -- 自增自减操作符。(导致“SyntaxError: invalid syntax”)

    如果你习惯于例如 C++ , Java , PHP 等其他的语言,也许你会想要尝试使用 ++ 或者 -- 自增自减一个变量。在Python中是没有这样的操作符的。

    该错误发生在如下代码中:

    也许这才是你想做的:

    17)忘记为方法的第一个参数添加self参数(导致“TypeError: myMethod() takes no arguments (1 given)”)

    该错误发生在如下代码中:

    展开全文
  • 函数是带有名字的代码块,函数的使用帮助我们在重复执行某项任务的时候,不需要重复的编写该方法,而是调用函数即可:定义一个函数 我们尝试用函数打印一个“Hello World” :def first_print():print("Hellowolrd")...

    265bcaf38d414b592953a3cec072f5d0.png

           
          函数是带有名字的代码块,函数的使用帮助我们在重复执行某项任务的时候,不需要重复的编写该方法,而是调用函数即可:

    6bcd591d7bc08379515e4b73a94f0125.png

        定义一个函数

         我们尝试用函数打印一个“Hello World” :

    def first_print():    print("Hello wolrd")first_print()first_print()

    第一行:定义一个 first_print的函数

    第二行:指明该函数需要打印一个Hello world

    第三行:调用first_print()

    第四行:   再次调用first_print()

    来看看执行结果:

    4b808a4d8bd7dba955b9128d7109de96.png

    程序打印了两遍"Hello World" ,这也告诉我们只要我们调用了函数,我们就能执行函数内部的代码。

    2dc706474cdcfcb0e1cad1d0c3ba7801.png

    向函数传递信息

            调用函数时,我们不仅能执行函数的内容,还能向函数传递一些信息,让函数更加灵活。针对上面例子来说,打印first_print 的,有可能时Tom ,也有可能时Jason , 如何在调用的时候可以指明,是谁打印的呢?

    def first_print(person_name):    print(person_name + " print Hello wolrd")first_print("Tom")first_print("Jason")

    第一行:定义一个 first_print的函数,并在函数中指明person_name , 通过这个person_name ,我们可以让函数接受我们指定的任何值

    第二行:指明该函数需要指明谁打印了一个Hello world

    第三行:调用first_print("Tom") ,由于函数指明需要一个参数,因此我们需要传递一个参数给函数,这个参数是“Tom“

    第四行:  调用first_print("Jason") ,由于函数指明需要一个参数,因此我们需要传递一个参数给函数,这个参数是“Jason“

    来看看执行结果:

    fac4526237af8c5f36700001b9705392.png

    函数调用显示是谁打印了”Hello world“

    在first_print() 中,变量person_name是一个形参,而”Tom” 、"Jason"

    则是调用函数时,我们传递给函数的实参,这两个概念了解一下

    74d503c3137cdf1169190f65959ac29c.png

    函数的位置实参

            实际上,你不只是可以向函数传递一个实参,如果我们传递两个以上的实参,那我们如何确定这两个实参和两个形参的对应关系呢? 最简单的方式就是按顺序来对应:

    def person_describe(person_name,person_height):    print("My name is "+person_name+", I am " + person_height)person_describe('Li Si','178CM')

    第一行:我们定义了一个函数,这个函数有两个形参

    第二行:打印含有参数的语句

    第三行:调用函数传递实参,而实参的顺序和形参的顺序一一对应

    看看执行结果:

    4c408d368422a9f2b93fabd454b93e42.png

    看到了吗,实参按顺序传递形参。并打印出来了。

    83335064f7fcb879f2e76e2750116343.png

    函数的关键字实参

    函数的关键字实参,提供给我们不按顺序传递参数的可能性:

    def person_describe(person_name,person_height):    print("My name is "+person_name+", I am " + person_height)person_describe(person_name='Li Si',person_height='178CM')person_describe(person_height='179CNM',person_name='Li Si')

    第一行:我们定义了一个函数,这个函数有两个形参

    第二行:打印含有参数的语句

    第三行:调用函数传递关键字实参,而实参的顺序和形参的顺序一致

    第四行:调用函数传递关键字实参,而实参的顺序和形参的顺序不一致

    看看执行结果:

    b8f513af0cc2d82607a6dcd06809dd65.png

    可以看到,在使用位置参数以后,即使调换了顺序,打印出来的结果也是一样。

    3e850faf43d8cac76b62fe2a07df765d.png

    上期答案与本期习题:

    上期答案

     1.请使用while 循环制作一个猜数字的游戏,规则是,你输入一个(1,100)的一个数字 ,而电脑随机生成一个1-100的数字,当你的数字和电脑数字相同时,打印”你赢了,你真棒“。如果用户输入的数字大于电脑生成的数字,则打印”你输入的数字太大了,请重新输入“, 反之打印”输入的数字太小了,请重新输入“。 

    答案参考公众号第一篇文章: 制作一个猜数字游戏

    本期习题

    1.定义一个函数,调用该函数,并在函数内打印”Hello !“

    2.定义一个函数,函数含有一个形参,调用该函数,并传递一个人名‘Jason ’的实参,并在函数内打印”Hello  Jason! “

    3.定义一个函数,含有两个形参,分别使用位置实参和关键字实参给函数传递参数,并打印含有两个参数的内容

    更多免费资料,请关注公众号

    57679f7f9038961fdf789f16ad32d9e5.gif

    2e1e55c372103a5854f76f719a76c11a.png

    展开全文
  • 定义函数的语法def 函数名(参数): 函数体 return 语句举例 定义一个的函数,表达式是y = x² + x# 提示:x ** y 表示 x的y次幂 def fc(x): y=x**2+x return y解释第1行:def的意思是定义(define),math是...

    定义函数的语法

    def 函数名(参数):
        函数体
        return 语句
    • 举例 定义一个新的函数,表达式是y = x² + x
    # 提示:x ** y 表示 x的y次幂
    def  fc(x):
        y=x**2+x
        return y
    • 解释
    第1行:def的意思是定义(define),math是【函数名】(自己取的),再搭配一个英文括号和冒号,括号里面
    的x是参数(参数名也是自己取)。
    
    第2行:def下一行开始缩进的代码就是函数要实现的功能,也叫【函数体】。这里的功能就是:根据x计算出一
    个值y
    
    第3行:return语句是返回的意思,可以指定函数执行完毕后最终会返回什么值或表达式,否则计算机是无法判
    断出函数最终要输出什么结果的。
    • 定义函数的语法并不难,但有些注意事项一开始要特别注意才能少踩坑,我将其标记在下面代码块的注释里,请你仔细阅读下
    # 函数名:1. 名字最好能体现函数的功能,一般用小写字母和单下划线、数字等组合 
    #      2. 不可与内置函数重名(内置函数不需要定义即可直接使用)
    def math(x): 
    # 参数:根据函数功能,括号里可以有多个参数,也可以不带参数,命名规则与函数名相同 
    # 规范:括号是英文括号,后面的冒号不能丢
         y = x ** 2 + 5 
    # 函数体:函数的执行过程,体现函数功能的语句,要缩进,一般是四个空格 
        return y 
    # return语句:后面可以接多种数据类型,如果函数不需要返回值的话,可以省略
    • 调用函数 输入函数名和参数所对应的值,这个过程在函数里叫作参数的传递(pass)
    def math(x):
        y =  x ** 2 + x
        return y
    
    a = math(10)
    print(a)
    
    输出结果:
    110
    
    解释:
    math(10)的意思是将整数10赋值给参数x并运行该函数。函数执行完毕后最终返回了y的值即110,然后将这个
    结果赋值给变量a,再用print()将变量a打印出来。
    当然,你也可以只用一行代码print(math(10))来表示同样的意思。
    • 举例 len()函数是Python的内置函数,功能之一是可以返回字符串的长度。我们可不可以自己写一个具有相同功能的函数呢?
    • 实现思路: 1. 设置一个初始为0的计数器;2.遍历字符串,每遍历一次,计数器加一;3.返回计数器的值。
    def my_len(words):
    #函数的参数是字符串
        y=0
        for i in(words):
            y=y+1
        return y
        
    print (my_len("三根皮带,四斤大豆"))
    
    输出结果:
    9
    

    参数类型

    def opening():
        print('一二三四五六七')
        print('葫芦娃呀葫芦娃')
        print('脑瓜疼啊脑瓜疼')
    
    opening()
    
    输出结果:
    一二三四五六七
    葫芦娃呀葫芦娃
    脑瓜疼啊脑瓜疼
    
    解释:
    我们可以看到,这里定义了一个opening()函数,但是括号里没有带参数,原因是这个函数的功能是打印出固定
    的三句话,不需要参数的参与。
    需要强调的是,即便是没有参数,我们在调用函数的时候也不能省略括号,如此例中的opening()
    在这个例子里,也不需要return语句,原因是这个函数直接在屏幕打印出内容,不需要返回值。事实上,没有
    return语句的函数,Python也会在末尾隐性地加上return None,即返回None值
    换句话说,有时候我们需要的只是函数的执行过程(比如打印内容),有时我们需要函数执行完毕的返回结果

    多个参数的情况

    def menu(appetizer, course):
        print('参数1:' + appetizer)
        print('参数2:' + course)
    
    menu('蛇皮精','葫芦娃')
    
    输出结果:
    参数1:蛇皮精
    参数2:葫芦娃
    
    解释:
    这里的'蛇皮精'和'葫芦娃'是对应参数的位置顺序传递的,所以appetizer和course被叫作【位置参数】,
    当有多个参数的时候,我们就必须按照顺序和数量传递,这也是最常见的参数类型。

    如果不按位置顺序传递,就会闹出乌龙。

    def menu(appetizer, course):
    
        print('参数1:' + appetizer)
        print('参数2:' + course+'n')
    
        #转义字符n,表示换行
    
    
    menu('蛇皮精','葫芦娃')
    
    menu('葫芦娃','蛇皮精')
    
    
    #如果采用下面这种形式传递,就不需要理会参数位置
    
    menu(course = '蛇皮精', appetizer = '葫芦娃')
    
    输出结果:
    参数1:蛇皮精
    参数2:葫芦娃
    
    参数1:葫芦娃
    参数2:蛇皮精
    
    参数1:葫芦娃
    参数2:蛇皮精
    

    如果一个函数的某个参数值总是固定的,那么设置默认参数就免去了每次都要传递的麻烦。不过默认参数并不意味着不能改变

    def menu(appetizer, course, dessert = '蝎子怪'):
        print('参数1:' + appetizer)
        print('参数3:' + course)
        print('参数2:' + dessert)
    
    
    menu('蛇皮精','葫芦娃')
    menu('蛇皮精','葫芦娃','蛤蟆精')
    #蛤蟆精对应参数dessert
    
    输出结果:
    参数1:蛇皮精
    参数3:葫芦娃
    参数2:蝎子怪
    参数1:蛇皮精
    参数3:葫芦娃
    参数2:蛤蟆精
    
    解释:
    一个萝卜一个坑,因为前两个位置参数已经有对应的值传递,Python会自动将'蛤蟆精'传递给参数dessert,
    替换了默认参数的默认值。

    下次更新...手困....

    休息了两小时...继续更新...

    我是全天下最帅的道长(*╹▽╹*)

    深度练习

    • 根据不同的使用环境 如果参数数量都不同,不能限定死数量,这时候【不定长参数】就能派上用场,即传递给参数的数量是可选的、不确定的。
    • 它的格式比较特殊,是一个星号*加上参数名,它的返回值也比较特殊,我们来看看下面的例子。
    def menu(*barbeque):
        return barbeque
    
    order = menu('烤鸡翅','烤茄子','烤玉米')
    #括号里的这几个值都会传递给参数barbeque
    
    print(order)
    print(type(order))
    
    输出结果:
    ('烤鸡翅', '烤茄子', '烤玉米')
    <class 'tuple'>
    
    
    解释:
    你会发现函数返回的是这样的结果:('烤鸡翅', '烤茄子', '烤玉米'),我们用type()函数可以知道这
    种数据类型叫作元组(tuple)
        注:元组的写法是将数据放在小括号()中,它的用法和列表用法类似,主要区别在于列表中的元素
    可以随时修改,但元组中的元素不可更改
    • 和列表一样,元组是可迭代对象,这意味着我们可以用for循环来遍历它,这时候的代码就可以写成:
     def menu(*barbeque):
        for i in barbeque:
            print('一份烤串:' + i)
    
    menu('烤香肠', '烤肉丸')        
    menu('烤鸡翅', '烤茄子', '烤玉米')
    # 不定长参数可以接收任意数量的值
    
    输出结果:
    一份烤串:烤香肠
    一份烤串:烤肉丸
    一份烤串:烤鸡翅
    一份烤串:烤茄子
    一份烤串:烤玉米
    • 可能目前我们不会怎么用到不定长参数,不过了解这一个概念可以帮助我们看懂一些函数文档
    • 比如说我们最熟悉的print()函数,它完整的参数其实是长这样的:
    print(*objects, sep = ' ', end = 'n', file = sys.stdout, flush = False)
    • 可以看到第一个参数objects带了*号,为不定长参数——这也是为什么print()函数可以传递任意数量的参数。其余四个为默认参数,我们可以通过修改默认值来改变参数,对比一下下列代码的输出结果。
    print('金枪鱼', '三文鱼', '鲷鱼')
    print('金枪鱼', '三文鱼', '鲷鱼', sep = '+')
    # sep控制多个值之间的分隔符,默认是空格
    print('金枪鱼', '三文鱼', '鲷鱼', sep = '+', end = '=?')
    # end控制打印结果的结尾,默认是换行)
    
    输出结果:
    金枪鱼 三文鱼 鲷鱼
    金枪鱼+三文鱼+鲷鱼
    金枪鱼+三文鱼+鲷鱼=?
    • 现在你明白了参数的不同形态,以后就可以视实际情况的需要,灵活设置不同的参数类型了

    返回多个值

    函数,不仅可以支持输入多个参数,而且也可以同时输出多个值吗。接下来,我们就来讲讲如何用return语句来返回多个值。


    注:随机功能我们可以用random模块中的random.choice()函数来):

    import random 
    #引入random模块
    
    appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
    def coupon(money):
        if money < 5:
            a = random.choice(appetizer)
            return a
        elif 5 <= money < 10:
            b = random.choice (appetizer)
            return b, '溏心蛋'
    
    print(coupon(3))
    print(coupon(6))

    可以看到:要返回多个值,只需将返回的值写在return语句后面,用英文逗号隔开即可。

    return b
    return '溏心蛋'

    切记!我们不能写成上面这种两行的格式,是因为函数在执行过程中遇到第一个return语句就会停止执行,所以第二个return '溏心蛋'永远不会被执行


    接下来我们直接运行下列的代码,看看返回的结果是什么数据类型。

    import random 
    appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
    def coupon(money):
        if money < 5:
            a = random.choice(appetizer)
            return a
        elif 5 <= money < 10:
            b = random.choice (appetizer)
            return b, '溏心蛋'
    
    print(coupon(6))
    print(type(coupon(6)))
    
    输出结果:
    ('拍黄瓜', '溏心蛋')
    <class 'tuple'>

    <class 'tuple'>表示返回的数据类型又是我们刚才提到的元组。在这个例子中,该元组是由两个元素构成的。

    元组和列表一样,可以通过索引来提取当中的某个元素,

    举例:将元组中的两个元素分别打印出来

    import random 
    appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
    def coupon(money):
        if money < 5:
            a = random.choice(appetizer)
            return a
        elif 5 <= money < 10:
            b = random.choice (appetizer)
            return b, '溏心蛋'
    
    result = coupon(6)
    # result是一个元组
    print(result[0])
    print(result[1])
    
    输出结果:
    凉拌三丝
    溏心蛋
    

    另外一种方式:我们也可以同时定义多个变量,来接收元组中的多个元素

    import random
    
    appetizer = ['话梅花生', '拍黄瓜', '凉拌三丝']
    
    def coupon(money):
        if money < 5:
            a = random.choice(appetizer)
            return a, ''
        elif 5 <= money < 10:
            b = random.choice(appetizer)
            return b, '溏心蛋'
    
    dish, egg = coupon(7)
    # 元组的两个元素分别赋值给变量dish和egg
    print(dish)
    print(egg)
    
    输出结果:
    凉拌三丝
    溏心蛋

    多个函数间的配合

    在实际编程中,我们会用函数来封装独立的功能,所以一个程序往往是通过多个函数的配合来实现的。


    当多个函数同时运行时,就涉及函数中一个非常重要的概念 —— 变量作用域。

    • 变量作用域
    举例
    rent = 3000
    
    def cost():
        utilities = int(input('请输入本月的水电费用'))
        food_cost = int(input('请输入本月的食材费用'))
        variable_cost = utilities + food_cost
        print('本月的变动成本费用是' + str(variable_cost))
    
    def sum_cost():
        sum = rent + variable_cost
        print('本月的总成本是' + str(sum))
    
    cost()
    sum_cost()
    

    乍一看代码好像没有什么问题,但是一旦运行,终端就会报错。

    ca456387ba04e2971b0db46c48253802.png

    解释:

    在这个例子中,变量rent是在函数外被赋值的,所以它是全局变量,能被sum_cost()函数直接使用。

    而变量variable_cost是在cost()函数内定义的,属于局部变量,其余函数内部如sum_cost()无法访问。事实上,当cost()函数执行完毕,在这个函数内定义的变量都会"消失”。

    那要怎么解决“局部变量”和”全局变量“之间的矛盾呢?有几种方法可供参考,第一种方法最取巧:把局部变量都放在函数外,变成全局变量。还是以上面的代码为例:

    rent = 3000
    utilities = int(input('请输入本月的水电费用'))
    food_cost = int(input('请输入本月的食材费用'))
    variable_cost = utilities + food_cost 
    # 以上均为全局变量
    print('本月的变动成本是' + str(variable_cost))
    
    def sum_cost():
        sum = rent + variable_cost
        print('本月的总成本是' + str(sum))
    
    sum_cost()

    那有没有一个能在函数内修改的方法呢?这时候global语句就能派上用场了,它可以将局部变量声明为全局变量,仔细看第四行代码。

    rent = 3000
    
    def cost():
        global variable_cost
        utilities = int(input('请输入本月的水电费用'))
        food_cost = int(input('请输入本月的食材费用'))
        variable_cost = utilities + food_cost
        print('本月的变动成本是' + str(variable_cost))
    
    def sum_cost():
        sum = rent + variable_cost
        print('本月的总成本是' + str(sum))
    
    cost()
    sum_cost()

    global语句一般写在函数体的第一行,它会告诉Python,“我希望variable_cost是个全局变量,所以请不要用这个名字创建一个局部变量”。所以sum_cost()函数内部现在可以直接使用声明后的全局变量variable_cost

    global语句我们就讲到这。要实现函数间变量的相互传递,还有一种更常用的方法就是利用函数的嵌套,这也是本次要将的最后一个知识点。

    函数的嵌套

    事实上,函数的嵌套我们并不陌生,最简单的例子就是print(len('我和你')),这里就是print()嵌套了len(),Python会先执行len()函数,得到一个返回值,再由print()打印出来。

    依葫芦画瓢,我们定义的函数也可以这样操作,即在一个函数内部调用其他函数,那么刚刚的例子就可以写成:

    rent = 3000
    
    def cost():
        utilities = int(input('请输入本月的水电费用'))
        food_cost = int(input('请输入本月的食材费用'))
        variable_cost = utilities + food_cost
        print('本月的变动成本是' + str(variable_cost))
        return variable_cost
    
    def sum_cost():
        sum = rent + cost()
        print('本月的总成本是' + str(sum))
    
    sum_cost()

    cost()函数运行结束后会返回变量variable_cost,而sum_cost()函数内部调用了cost(),所以调用sum_cost()的时候,cost()函数也会执行,并得到返回值variable_cost

    sum = rent + cost()的结果就是sum = rent + variable_cost。最后调用函数时,也只需调用sum_cost()即可。

    接下来我们再来看个例子:

    请你阅读下面三个函数,弄明白当调用main()主函数的时候,程序是怎么运行的

    def div(num1, num2):
        growth = (num1 - num2) / num2
        percent = str(growth * 100) + '%'
        return percent
    
    def warning():
        print('Error: 你确定上个月一毛钱都不赚不亏吗?')
    
    def main():
        while True:
            num1 = float(input('请输入本月所获利润'))
            num2 = float(input('请输入上月所获利润'))
            if num2 == 0:
                warning()
            else:
                print('本月的利润增长率:' + div(num1,num2))
                break
    
    main()

    可以看到,div()函数会计算并返回利润率,warning()函数是打印出一句提示,它们都被嵌套在main()主函数里,当满足不同的条件时,这两个子函数会被调用。

    所以虽然定义了三个函数,但最后只需调用main()函数即可。

    有些兄弟可能还是会疑惑:代码不是从上往下一行一行执行吗,为什么不是依次执行div()warning()main()呢?

    道长在此再强调一下,def语句后的代码块只是封装了函数的功能,如果没有被调用,那么def语句后面的代码永远不会被执行。

    这里的调用语句是main(),所以会直接执行main()函数里的代码,我们可以结合注释来看下这段代码的执行顺序:(按箭头所标的序号)

    3856f896174bd7079661eebbb10de419.png

    ok,关于Python定义函数的内容就讲到这里了,记得多做练习

    展开全文
  • typedef定义函数指针

    2020-11-10 18:18:36
     typedef 类型 定义名; 栗子: typedef char *pChar; pChar s1, s2, s3; 注意:s1、s2、s3都被定义为char *类型. 2.创建一个的类型 typedef 返回值类型 类型(参数列表); 栗子: typedef int (*add)(int...
    一、typedef两种用法
    1.定义已有类型的别名
     typedef   类型    定义名;
    
    栗子:
    typedef char *pChar; 
    pChar s1, s2, s3; 
    注意:s1、s2、s3都被定义为char *类型.
    
    2.创建一个新的类型
     typedef   返回值类型   新类型名(参数列表);
    栗子:
     typedef int (*ADD)(int, int); //ADD为返回int类型的函数指针
    等同:
     int(*ADD)(int, int);
    函数实现:
    
    //ADD为返回int类型的函数指针,返回int类型的函数指针
    ADD calc_func(int x, int y){
      //return add(x + y);
    }
    
    <1>.注意:去掉typedef和别名后, 剩下的原变量的类型:
    int (*)(int, int)
    
    <2>.typedef定义了新的类型add,并定义这种类型是指向函数的指针,这个函数以一个(int,int)为参数,并返回int类型.
    
    <3>.再如:
     typedef int* (*ADD)(int, int); 
    注意:typedef定义了新的类型add,并定义这种类型是指向函数的指针,这个函数以一个(int,int)为参数,并返回init*类型.
    
    //ADD为返回int类型的函数指针,返回int*类型的函数指针
    ADD calc_func(int x, int y){
      //return add(x + y);
    }
    

     

    展开全文
  • 函数定义

    2018-06-07 21:29:00
    同包含对象指针的其他变量没区别,也就是说,一个函数可能会有多个名字,在下面的代码中,先定义了一个名为sum()的函数,用于求两个数的和,在将sum的值赋给一个的变量anoanotherSum(使用不带圆括号的函数名是访问...
  • lastname没有加this,输出的就不是p1对象里的成员lastname,根据作用域上下文看是构造函数上的那个... 在下面的示例中,定义了一个具有一个简单的构造函数为 Taxi 的类。然后使用 new 运算符来实例化该类。ja...
  • ## 内建函数示意图:![](https://img.kancloud.cn/51/bf/51bf779cade57de2975da7532a27a611_700x563.png)通过观察规律其实不难发现,Python中所谓的使用函数就是把你要处理的对象放到一个名字后面的括号里就可以了。...
  • 函数名定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量,...
  • 在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。自定义一个求绝对值的my_abs函数: def my_abs(x): if x &...
  • 1Python3中必须通过“def 函数名(参数1, 参数2, …): 语句块”的格式定义一个自定义函数。启动IDLE程序,在输入提示符中输入“def dump(v):”并回车,然后在下一行中输入“print(v)”并回车。接着,连续按2次回车键...
  • 通常我们会看到以下两种定义函数的方式: // 函数语句 function fn(str) { console.log(str);...两种方式都创建了的函数对象, 但函数声明语句的函数名是一个变量名, 变量指向函数对象, 和...
  • __FUNCTION__返回函数名的宏定义

    千次阅读 2015-11-01 19:35:13
    为了获取函数名,就在函数体中嵌入硬编码的字符串,这种方法单调乏味还易导致错误,不如看一下怎样使用的C99特性,在程序运行时获取函数名吧。   对象反射库、调试工具及代码分析器,经常会需要在运行时访问...
  • JavaScript语言基础 ...function 函数名(){ // 执行代码 } JavaScript 对大小写敏感,关键词 function 必须是小写的,并且必须以与函数名称相同的大小写来调用函数。 定义函数 定义方式一 //定义一...
  • 在javascript中,函数有两种定义写法,... } 尽管函数定义表达式和函数声明语句包含相同的函数名,并且都创建了的函数对象,但是这二者却有区别。 函数声明语句中的函数名是一个变量名,变量指向函数对象。 函
  • 是指同一作用域的不同函数使用相同的函数名,但是参数个数或类型不同(参数个数、参数类型或参数顺序) 成员函数被重载的特征 (1)相同的作用域(同一个类中); (2)函数名字相同; (3)参数不同; (4)virtual...
  • 函数名定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量,...
  • 函数名定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量,...
  • 一:函数的缺省参数(在实际调用中,实参的个数可以少于形参个数)1、语法:def 函数名(形参名1=默认实参1,形参名2=默认实参2……)示例:def info(name, age=1.address=’未填写’):print(name,’今年’, age, ‘岁, ...
  • 定义函数 关键字 def 引入函数的定义。其后必须跟有函数名和以括号标明的形式参数列表。组成函数体的语句从下一行开始,且必须缩进。 执行 一个函数会引入一个用于函数的局部变量的符号表。 因此,在函数内部...
  • 新式函数声明C++11/14增加了一种的函数语法,允许返回值类型后置,它使用了auto/ decltype的类型推导能力,基本形式是:auto func(...) ->...其次,函数名后需要用“-> type” 的形式来声明真正的返回...
  • 函数名定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量...
  • 函数是可以实现一些特定功能的方法或是程序,简单的理解下函数的概念,就是你编写了一些语句,为了方便使用,把这些语句组合在一起,给它起一个名字,即函数名。使用的时候只要调用这个名字,就可以实现语句组里的...
  •  而函数的作用于此类似,对于需要重复使用的代码,我们可以通过定义一个函数来,给这个函数起一个名字(新定义函数不能喝系统函数重名,这个一定要记住!)之后调用名称即可.所以函数的作用,可以避免重复
  • 定义函数 def 函数名(参数列表): 函数体 return 表达式 调用函数 通过“函数名()”即可完成调用 函数的参数 默认参数 定义函数时,可以给函数的参数设置默认值,这个参数就被称为默认参数。如果默认参数没有传入...
  • 函数名定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量...
  • 函数指针定义

    2016-08-20 18:27:00
    //形式1:返回类型(*函数名)(参数表)void(*pFunc)(string); 用法:pFunc = func;  (*pFunc)("str"); 2.使用typedef更直观更方便。//形式2:typedef 返回类型(*类型)(参数表)typedef void(*pFunc)(stri...
  • 函数其它定义方式

    2019-04-21 18:48:24
    1、未命名的函数称为匿名函数 function(){函数体} 函数表达式 var 变量 = function(){函数体}; 变量();...命名函数 函数名重名最新的会覆盖旧的 而函数表达式不会 var f1 = function () { conso...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,458
精华内容 1,383
关键字:

新定义函数名