精华内容
下载资源
问答
  • python中定义函数的关键字是什么
    万次阅读
    2020-12-03 13:00:19

    函数代码块以def关键字开头,后接函数标识符名称和圆括号(),任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数,函数内容以冒号起始,并且缩进。

    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

    函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。

    定义一个函数

    可以定义一个由自己想要功能的函数,以下是简单的规则:

    1.函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。

    2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

    3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

    4.函数内容以冒号起始,并且缩进。

    5.return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

    语法

    Python 定义函数使用 def 关键字,一般格式如下:def 函数名(参数列表):

    函数体

    默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。

    示例

    让我们使用函数来输出"Hello World!":>>>def hello() :

    print("Hello World!")

    输出结果

    >>> hello()

    Hello World!

    阅读:次

    更多相关内容
  • Python中函数定义.函数的概念: 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你...

    Python中函数定义:

    一.函数的概念:
    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。所谓函数,就是把具有独立功能的代码块组织成为一个小模块,在需要的时候调用。

    二.函数的作用:
    在开发时,使用函数可以提高编写的效率以及代码的重用,需要在程序中多次执行同一项任务时,你无需反复编写完成该任务的代码,而只需调用该任务的函数,让python运行其中的代码,你将发现,通过使用函数,程序编写,阅读,测试和修复都将更容易。

    三.如何定义函数:
    def 函数名 ( ):
    函数封装的代码
    1.def是英文define的缩写
    2.函数名称应该能够表达函数封装代码的功能,方便后续的调用
    3.函数名称的命名应该符合标识符的命名规则
    可由字母,下划线和数字组成
    不能以数字开头
    不能与关键字重名

    四.函数中的形参与实参:
    参数的作用:
    把具有独立功能的代码块组织成为一个小模块,在需要的时候调用函数的参数,增加函数的通用性,针对相同的数据处理逻辑,能够适应更多的数据
    1.在函数内部,把参数当作变量使用,进行需要的数据处理
    2.函数调用时,按照函数定义的参数顺序,把希望在函数内部处理的数据,通过
    参数传递

    形参和实参:
    形参:定义函数时,小括号中的参数,是用来接收参数用的,在函数内部作为变量使用
    实参:调用函数时,小括号中的参数,是用来把数据传递到函数内部用的

    五.函数的返回值:
    函数的返回值
    在程序开发中,有时候,会希望一个函数执行结束后(举例子:温度计函数,要返回给我们当前的温度,告诉调用者一个结果,以便调用者针对具体的结果作出后续的处理,返回值是函数完成工作后,最后给调用者的一个结果,在函数中使用return关键字可以返回结果,调用函数一方,可以使用变量来接收函数的返回结果

    六.全局变量与局部变量:
    局部变量和全局变量:
    局部变量是在函数内部定义的变量,只能在函数内部使用
    全局变量是在函数外部定义的变量,(没有定义在某一个函数内),所有函数内部都可以使
    用这个变量

    局部变量:
    局部变量是在函数内部定义的变量,只能在函数内部使用
    函数执行结束后,函数内部的局部变量,会被系统回收
    不同的函数,可以定义相同的名字的局部变量,但是各用各的不会产生影响

    局部变量的作用:
    在函数内部使用,临时保存函数内部需要使用的数据

    七.函数的实验:
    1.定义一个函数:

    #  定义好一个函数之后,只是表示这个函数封装了一段代码
    #  如果不主动调用函数,函数是不会主动执行的
    
    
    def say_hello():
        print 'hello1'
        print 'hello2'
        print 'hello3'
    #调用函数
    say_hello()

    这里写图片描述

    2.定义一个实现两个数字求和函数:

    #  能实现两个数字求和
    
    
    def sum_sum():
        number1 = 10
        number2 = 20
        result = number1 + number2
        print '%d + %d = %d' % (number1,number2,result)
    sum_sum()

    这里写图片描述

    3.形参和实参:

    #  形参:定义函数时,小括号中的参数,是用来接收参数使用
    #  在函数内部,是当作变量来用的
    
    
    def sum_sum(num1,num2):
        """对两个数字求和"""
        result = num1 + num2
        print '%d+%d=%d' % (num1,num2,result)
    #  实参:调用函数时使用的,小括号中的参数,是用来把数据传递到函数的内部
    sum_sum(27,13)

    这里写图片描述

    4.函数的返回值:

    #  返回值:是函数完成工作后,最后给调用者的一个结果,在函数中使用return关键字可以返回结果,调用函数一方,可以使用来接收函数的返回结果
    
    
    def sum_2_sum(num1,num2):
        """对两个函数求和"""
        result = num1 + num2
        return result
    
    sum_result = sum_2_sum(45,50)
    print sum_result

    这里写图片描述

    **5.**return 表示返回,后续代码不会执行:

    def sum_2_num(num1,num2):
        result = num1 + num2
        return result
        num = 1000
        print  num
    sum_result = sum_2_num(30,30)
    print sum_result
    name = '234'

    这里写图片描述

    6 打印分割线:

    #  1.定义一个函数打印一条分割线
    
    
    def print_line():
        print '*' * 50
    
    print_line()
    
    # 2.定义一个函数打印由任意字符串组成的分割线
    def print_line(char):
        print char * 50
    
    print_line('#')
    
    # 3.定义一个函数能够打印任意重复次数的分割线
    def print_line(char,times):
        print char * times
    
    print_line('$',40)
    
    # 4.定义一个函数可以打印五行分割线,分割线要求符合要求3
    #def print_line(char,times):
        #print char * times
    def print_lines():
        row = 0
        while row < 5:
            print_line('%',50)
            row += 1
    
    print_lines()
    
    # 5.自己输入字符串与个数
    #def print_line(char,times):
        #print char * times
    def print_lines(char,times):
        row = 0
        while row < 5:
            print_line(char,times)
            row += 1
    
    print_lines('^',50)

    这里写图片描述

    7.全局变量:

    """
    全局变量
    定义的全局变量在函数外定义
    """
    num = 10
    def demo1():
        #num = 99 #使用赋值语句,只是在函数内部定义一个变量与demo2没关系
        print 'demo1=====> %d' % num
    def demo2():
        print 'demo2=====> %d' % num
    
    demo1()
    demo2()

    这里写图片描述

    8.局部变量:

    """
    局部变量
    不同的函数可以定义相同名字的局部变量,但不会产生影响
    """
    def demo1():
        #定义一个局部变量
        num = 10
        print num
    #def demo2():
        # demo1中定义的局部变量不能在其他函数中使用
    
    demo1()
    #demo2()

    这里写图片描述

    9.修改全局变量的值:

    """
    希望修改全局变量的值,使用global关键字,声明一下变量即可
    global 关键字会告诉解释器后面是一个全局变量
    再用赋值语句时 就不会创建局部变量
    
    
    """
    num =10
    def demo1():
        global num
        num = 99
        print 'demol======> %d' % num
    def demo2():
        print 'demo2======> %d' % num
    
    demo1()
    demo2()

    这里写图片描述

    Python中的循环语句:

    一.if判断语句:
    1.判断的定义:
    如果条件满足,才能做某件事
    如果条件不满足,就做另外一件事情,或者什么也不做
    正是有了判断,才使得程序世界丰富多彩,充满变化(程序不再从上到下的‘呆
    板’执行了)
    判断语句又被称为‘分支语句’,正是因为有了判断,才让程序有了很多的分支

    2. if 判断语句的基本语法
    if 要判断的条件:
    条件成立时,要做的事情
    注意:代码的缩进为一个 tab 键,或者四个空格(pycharm 自动帮我们增加)
    在 python 开发中,Tab 和空格不要混用

    3.判断语句演练:
    需求:
    1.定义一个整数变量
    2.判断是否满 18 岁(>=)
    3.如果满 18 岁,允许进入网吧

    #  1.定义一个整数变量
    age = 18
    #  2.判断是否18岁
    if age >= 18:
    #  3.如果18岁,欢迎进入网吧
        print '欢迎进入网吧'

    这里写图片描述

    4. else:
    else,格式如下 #注意 else 必须配合 if 使用,而其 else 后不跟条件
    if 要判断的条件:
    条件成立时,要做的事情
    ……
    else:条件不成立时,要做的事情
    ……
    if 和 else 语句以及各自的缩进部分是一个完整的代码块
    示例:
    需求
    1.输入用户年龄
    2.判断是否满 18 岁(>=)
    3.如果满 18 岁,允许进入网吧
    4.如果未满 18 岁,提示回家写作业

    age = int(raw_input('请输入你的年龄:'))
    #  1.判断年龄是否为18岁
    if age >= 18:
    #  2.如果满18岁,允许进入网吧
        print '欢迎进入网吧'
    #  3.如果不满18岁,请回家写作业
    else:
        print '请回家写作业'

    这里写图片描述

    5.逻辑运算:
    在程序开发中,通常在判断条件时,会需要同时判断多个条件
    只有多个条件都满足,才能够执行后续代码,这个时候需要使用到逻辑运算符
    逻辑运算符可以把多个条件按照逻辑进行连接,变成更复杂的条件
    python 中的逻辑运算符包括:与 and/或 or/非 not 三种

    and:
    条件 1 and 条件 2
    与/并且
    两个条件同时满足,返回 True
    只需有一个不满足,就返回 False

    or:
    条件 1 or 条件 2
    或/或者
    两个条件只要有一个满足,返回 True
    两个条件都不满足,返回 False

    not:
    对一个条件取反:not 条件

    逻辑运算演练:
    1.练习:定义一个整数变量 age,编写代码判断年龄是否正确要求人的年龄在 0~120 之间
    2.练习:定义两个整数变量 python_score,c_score,编写代码判断成绩
    3.练习:定义一个布尔型变量 is_employee,编写代码判断是否是本公司员工
    如果不是提示不允许入内

    #  1.定义一个整数变量,要求年龄在0~120岁之间
    age = int(raw_input('请输入你的年龄:'))
    if age >= 0 and age <= 120:
            print '年龄符合要求'
    else:
            print '年龄不符合要求'
    
    #  2.定义两个整数变量记录成绩,只要有一门成绩>60,就算考试合格
    python_score = int(raw_input('请输入python成绩:'))
    linux_score = int(raw_input('请输入linux成绩:'))
    if python_score > 60 or linux_score > 60:
        print '恭喜你,考试通过!'
    else :
        print '请继续努力!'
    
    #  3.定义一个布尔型变量,判断是否为本公司员工
    is_employee = False
    if not is_employee:
        print '非本公司员工,请离开!!!'

    这里写图片描述

    6. elif:
    在开发中,使用 if 可以判断条件
    使用 else 可以处理条件不成立的情况
    但是,如果希望再增加一些条件,条加不同,需要执行的代码也不同,就可以使用

    elif语法格式如下:
    if 条件 1:
    条件 1 满足执行的代码
    elif 条件 2:
    条件 2 满足时,执行的代码
    else:
    以上条件都不满足时,执行的代码

    注意:
    elif 和 else 都必须和 if 联合使用,而不能单独使用
    可以将 if,elif 和 else 以及各自缩进的代码,看成一个完整的代码块
    elif 演练—女盆友的节日

    需求:
    1.定义 holidy_name 字符串变量记录节目名称
    2.如果是情人节应该 买玫瑰/看电影
    3.如果是平安夜应该 买苹果/吃大餐
    4.如果是生日 应该 买蛋糕
    5.其他的日子每天都是节日

    #  定义holiday_name字符串变量记录节日的名称
    holiday_name = str(raw_input('请输入节日名称:'))
    
    if holiday_name == '情人节':
        print '买玫瑰'
        print '看电影'
    elif holiday_name == '平安夜':
        print '送口红'
        print '吃大餐'
    elif holiday_name == '生日':
        print '买蛋糕'
        print '送口红 全套'
    else:
        print '每一天都是节日'

    这里写图片描述
    这里写图片描述

    7. if 的嵌套:
    生活中的例子:(火车站的二次安检 首先得先有片进入火车站候车大厅)
    elif 的应用场景是:同时判断多个条件,多有的条件都是平级的在开发中,使用 if 进行条件判断,如果希望在条件成立的执行语句中再增加条件判
    断,就可以使用 if 的嵌套
    if 的嵌套的应用场景就是:在之前的条件满足的前提下,再增加额外的判断
    if 的嵌套的语法格式,除了缩进之外和之前的没有区别

    语法格式:
    if 条件 1:
    条件 1 满足执行的代码
    ….
    if 条件 1 基础上的条件 2:
    条件 2 满足时,执行的代码
    ….
    条件 2 不满足的处理
    else:
    条件 2 不满足时,执行的代码
    ….
    条件 1 不满足时候的处理
    else:
    条件 1 不满足时,执行的代码
    ….

    需求:
    1.定义布尔型变量 has_ticket 表示是否有其票
    2.定义整型变量ML_liquid表示液体毫升
    3.首先检查是否有机票,如果有,才允许进行安检
    4.安检时,需要检查液体毫升,判断是否超过 100ml
    如果超过100ml,提示液体毫升数超过100毫升,超过限定数量,不允许登机.
    如果不超过 100ml’,液体毫升数没超过100毫升,没超过限定数量,允许登机.
    5.如果没有机票,不允许进门

    #  1.定义布尔型变量has_ticket表示是否有机票
    has_ticket = True
    #  2.定义液体的量(毫升)
    ML_liquid = int(raw_input('输入液体毫升数:'))
    #  3.是否有机票,如果有,允许进入
    if has_ticket:
        print '允许通过'
    #  4.判断液体的量
        if ML_liquid >100:
            print '液体毫升数超过100毫升,超过限定数量,不允许登机. '
        else:
            print '液体毫升数没超过100毫升,没超过限定数量,允许登机. '
    else:
        print '请先购票!'

    这里写图片描述
    这里写图片描述

    8.综合应用–石头剪刀布
    目标:
    1.强化多个条件的逻辑运算
    2.体会 import 导入模块(工具包)的使用
    需求:1.从控制台输入要出的拳 —石头(1)/剪刀(2)/布(3)
    2.电脑随即出拳–先假定电脑只会出石头,完成整体代码功能
    3.比较胜负
    石头 胜 剪刀
    剪刀 胜 布
    布 胜 石头

    import random
    #  1.从控制台输入要出的拳:石头:1 剪刀:2 布:3
    player = int(raw_input('输入你要出的拳:'))
    #  2.电脑随机出拳
    computer  = random.randint(1,3)
    print '玩家选择的是 %d  电脑选择的是 %d' % (player,computer)
    #  比较胜负:
    if ((player == 1 and computer == 2) or
            (player == 2 and computer == 3) or
            (player == 3 and computer == 1)):
        print 'PLAYER WIN!!'
    elif player == computer:
        print 'PLAY EVEN'
    else:
        print 'COMPUTER WIN!'

    这里写图片描述

    二.while循环语句:
    1. while 循环的基本使用:
    循环的作用就是让指定的代码重复的执行
    while 循环最常用的应用场景就是让执行的代码按照指定的次数重复执行

    2. hile 语句的基本语法:
    初始条件设置 – 通常是重复执行的 计数器 (eg:i=1)
    while 条件(判断 计数器 是否达到目标 目标次数):
    条件满足时,做的事情 1
    条件满足时,做的事情 2
    条件满足时,做的事情 3
    条件满足时,做的事情 4
    ………
    处理条件(计数器 +1)
    while 语句及缩进部分是一个完整的代码块

    3. python 中的计数方法:
    常见的计数方法有两种,可以分为
    自然计数法(从 1 开始) – 更符合人类的习惯
    程序计数法(从 0 开始) – 几乎所有的程序语言都选择从 0 开始计数
    因此,大家在编写程序时,应该尽量养成习惯:除非需求的特殊要求,否则循环的
    计数从 0 开始

    4. 循环计算:
    在程序开发中,通常会遇到利用循环重复计算的需求
    遇到这种情况:
    1.在 while 上方定义一个变量,用于存放最终的计算结果
    2.在循环体内部,每次循环都用最新的计算结果,更新之前定义的变量

    需求:
    计算 0~100 之间所有数字的累计求和的结果

    #  计算0~100之间数字的求和
    i = 0
    result = 0
    while i <= 100:
        print i
        result += i
        i += 1
    print '0~100之间数字的求和结果是:%d' % result
    
    

    这里写图片描述

    需求进阶:
    计算 0~100 之间所有偶数的累计求和

    #  计算0~100之间偶数的求和
    i = 0
    result = 0
    while i <= 100:
        print i
        result += i
        i += 2
    print '0~100之间数字的求和结果是:%d' % result

    这里写图片描述

    **5.**break 和 continue:
    break 和 continue 是专门在循环中使用的关
    break 和 continue 只针对当前所在循环有效键字

    break 某一条满足时,退出循环,不再执行后续重复的代码

    i = 0
    while i < 10:
        if i == 3:
            #  满足i=3条件时,退出循环
            #  不再执行后续重复的代码
            break
        print i
        i += 1
    print 'over'

    这里写图片描述

    continue 某一条满足时,不执行后续重复的代码,其他条件统统要执行

    i = 0
    while i < 10:
        i += 1
        if i == 3:
            #  满足i=3条件的时候,不执行后续重复的代码
            #  其他条件的代码都要执行
            continue
        print i

    这里写图片描述

    6. 实验练习:
    打印出下图:
    *
    * *
    * * *
    * * * *
    * * * * *

    """
    row = 1   #  行
    while row <= 5:
        col = 1   #  列
        while col <= row:
            col += 1
            print '*',    #  加 , 换行
        print ''
        row += 1
    
    

    这里写图片描述

    九九乘法表:

    row = 1   #  行
    while row <= 9:
        col = 1  #  列
        while col <= row:
            print '%d*%d=%d\t' % (row,col,row*col),     #  \t 垂直对齐
            col += 1
        print ''
        row += 1

    这里写图片描述

    展开全文
  • 函数定义 函数与过程 返回值与返回值类型 前向引用 内部/内嵌函数 函数装饰器 传递函数 参数的种类 位置参数 参数默认值 命名关键字参数 关键字参数:**others,便于函数功能的扩展 任意的参数列表 *...

    目录

    函数与函数式编程

    函数的定义

    函数与过程

    返回值与返回值类型

    前向引用

    内部/内嵌函数

    函数装饰器

    传递函数

    参数的种类

    位置参数

    参数默认值

    命名关键字参数

    关键字参数:**others,便于函数功能的扩展

    任意的参数列表 *others

    解包参数列表  

    解包参数列表  


    函数与函数式编程

    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

    函数能提高应用的模块性,和代码的重复利用率。Python提供了许多内建函数,比如print()。我们也可以自己创建函数,这被叫做用户自定义函数。

    函数的定义

    我们可以定义一个由自己想要功能的函数,以下是简单的规则:

    函数代码块以def关键词开头,后接函数标识符名称和圆括号()。

    任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

    函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

    函数内容以冒号起始,并且缩进。

    return[表达式]结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回None。

    以创建一个输出任意范围内 Fibonacci 数列的函数为例:

    def fib(n):
        a,b=0,1
        while a<n:
            print(a,end=" ")
            a,b=b,a+b
        print()
    fib(2000)

    关键字def引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表。构成函数体的语句从下一行开始,并且必须缩进。

    函数体的第一个语句可以(可选的)是字符串文字;这个字符串文字是函数的文档字符串或docstring。

    函数的执行会引入一个用于函数局部变量的新符号表。更确切地说,函数中所有的变量赋值都将存储在局部符号表中;而变量引用会首先在局部符号表中查找,然后是外层函数的局部符号表,再然后是全局符号表,最后是内置名称的符号表(变量作用域问题,之后会详细介绍)。因此,全局变量和外层函数的变量不能在函数内部直接赋值(除非是在global语句中定义的全局变量,或者是在nonlocal语句中定义的外层函数的变量),尽管它们可以被引用。

    在函数被调用时,实际参数(实参)会被引入被调用函数的本地符号表中;因此,实参是通过按值调用传递的(其中值始终是对象引用而不是对象的值)。当一个函数调用另外一个函数时,将会为该调用创建一个新的本地符号表。

    函数定义会把函数名引入当前的符号表中。函数名称的值具有解释器将其识别为用户定义函数的类型。这个值可以分配给另一个名称,该名称也可以作为一个函数使用。这用作一般的重命名机制:

    print(fib)
    f=fib
    f(
    100)

    上面这个函数是无返回值的函数,即没有return语句,默认返回None。一般来说解释器不会打印出单独的返回值None,如果真想看到它,可以使用print()

    print(fib(0))

    print(fib(1))

    写一个返回斐波那契数列的列表(而不是把它打印出来)的函数,非常简单:

    def fib2(n):
        result=[]
        a,b=0,1;
        while a<n:
            result.append(a)
            a,b=b,a+b
        return result
    f100=fib2(100)
    print(f100)

    函数与过程

    函数与过程都是可以被调用的实体,一般来说,函数有一定的返回值,过程是简单、特殊、没有返回值的函数。

    返回值与返回值类型

    当没有返回值时,Python的实际返回对象是None。

    当返回对象的数目为1时,Python的返回值类型是该对象的类型。

    当返回对象的数目大于1时,Python的返回值类型是元组。

    def fun1():
        pass
    print(fun1())
    def fun2():
        return '123'
    print(fun2())
    def fun_list():
        return ['123','xyz',456]
    print(fun_list())
    def fun_tuple1():
        return 1,2,3
    print(fun_tuple1())
    def fun_tuple2():
        return (1,2,3)
    print(fun_tuple2())

    运行结果:

    None

    123

    ['123', 'xyz', 456]

    (1, 2, 3)

    (1, 2, 3)

    fun1()返回None,fun2()的返回值类型是字符串,fun_list()、fun_tuple1()、fun_tuple2()的返回值大于1个,fun_list()返回的是一个列表,fun_tuple1()、fun_tuple2()等价,都是一个元组。

    所以在我们看来。返回一个容器对象时,好像是返回了多个对象(元组在语法上不需要带括号),事实上,他们仍返回的是一个,一个容器罢了。

    保存元组返回值的三种方法:

    def fun_tuple():
        return 'abc',5,['k','p']
    aTuple=fun_tuple()
    x,y,z=fun_tuple()
    (a,b,c)=fun_tuple()
    print(aTuple)
    print(x,y,z)
    print((a,b,c))

    运行结果:

    ('abc', 5, ['k', 'p'])

    abc 5 ['k', 'p']

    ('abc', 5, ['k', 'p'])

    在对x、y、z和a、b、c的赋值中,根据返回值的顺序,每个变量会接收到与之对应的返回值。而aTuple直接获得函数隐式返回的整个元组。

    前向引用

    def foo():
        print(
    '1')
        bar()

    def bar():
        print(
    '2')
    foo()

    运行结果:

    1

    2

    可见上例中foo()先调用的bar(),然后bar()才声明,系统不会报错。但是不推荐这么写,从感觉上来说,有悖常识,自己尽量让需要用的放在前面吧。

    内部/内嵌函数

    在函数体内部创建另外一个函数是完全合法的,这种函数叫内嵌函数。

    如:

    def foo():
        print('1')
        def bar():
            print('2')
        bar()
    foo()

    运行结果:

    1

    2

    内部函数的整个函数体都在外部函数的作用域里。如果没有任何对bar()的外部引用,那么除了在外部函数体foo()内,任何其他地方都不能对其进行调用。

    另外一个函数体内创建函数对象的方式是使用lambda语句。这个之后的学习会涉及。

    函数装饰器

    暂时看不懂,先不写。

    传递函数

    传递函数的方式大致有三种:

    1. 被引用(访问或者以其他变量作为其别名)
    2. 作为参数传入函数
    3. 作为字典、列表等容器对象的元素

    下面详细介绍一下用其他的变量作为函数的别名。

    def foo():
        print('1')
    bar=foo
    bar()

    运行结果:

    1

    当我们把foo赋给bar时,bar和foo引用了同一个函数对象,所以能以调用foo()相同的方式调用bar()。

    故:foo是函数对象的引用;foo()是函数对象的调用。

    再如:

    def foo():
        print('1')
    def bar(argfunc):
        argfunc()
    bar(foo)

    运行结果:

    1

    参数的种类

    位置参数

    位置参数必须以在被调用函数中的定义的准确顺序来传递。若没有任何默认参数的话,传入函数的参数的精确的数目必须和声明中的数字一致。

    当然,我们也可以不按位置地将关键字参数传入函数,给出关键字来匹配其在参数列表中的合适位置,但是位置参数的数字一定要对。

    def info(name,sex,grades,school='abc'):
        print(name)
        print(sex)
        print(grades)
        print(school)
    info('Jennifer','female','3')
    print()
    info(sex='female',name='Jennifer',school='lalala',grades='1')
    print()
    info(grades='1',sex='male',name='frank')

    运行结果:

    Jennifer

    female

    3

    abc

     

    Jennifer

    female

    1

    lalala

     

    frank

    male

    1

    abc

    参数默认值

    最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数,可以用比定义时允许的更少的参数调用,设置默认参数,必选参数在前,默认参数在后。比如:

    def ask_ok(prompt,retries=4,reminder='Please try again!'):
        while True:
            ok=input(prompt)
            if ok in ('y','ye','yes'):
                return True
            if ok in ('n','no','nop','nope'):
                return False
            retries=retries-1
            if retries<0:
                raise ValueError('invalid user response')
            print(reminder)

    这个函数可以通过几种方式调用:

        只给出必需的参数:ask_ok('Do you really want to quit?')

        给出一个可选的参数:ask_ok('OK to overwrite the file?', 2)

    或者给出所有的参数:ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

    这个示例还介绍了 in 关键字。它可以测试一个序列是否包含某个值。

    默认值是在定义过程中在函数定义处计算的,所以下例会打印5。

    i=5
    def f(arg=i):
        print(arg)
    i=6
    f()

    重要警告: 默认值只会执行一次这条规则在默认值为可变对象(列表、字典以及大多数类实例)时很重要。比如,下面的函数会存储在后续调用中传递给它的参数:

    def f(a,L=[]):
        L.append(a)
        return L
    print(f(1))
    print(f(2))
    print(f(3))

    打印结果如下:

    如果你不想要在后续调用之间共享默认值,你可以这样写这个函数:

    def f(a,L=None):
        if L is None:
            L=[]
        L.append(a)
        return L
    print(f(1))
    print(f(2))
    print(f(3))

    命名关键字参数

    函数调用时,指定参数名称,称为关键字参数(别和默认参数混淆,这里是函数调用)

    def temp(a,b,c):
    
        print(a)
    
        print(b)
    
        print(c)
    
    temp(1,3,c=99)
    
    temp(a=1,b=2,c=3)
    
    temp(1,b=2,c=100)

    顺序要求:函数调用时,关键字参数必须在普通参数(位置参数)的后面

    temp(100,b=200,c=300)

    temp(a=100,32,100) #错误语法,关键字参数不能在普通参数的前面

    使用字典解包方式传入关键字参数(后面小节中会详细讲到)

    hi = {"a":100,"b":99,"c":1000}

    temp(**hi) #等同于下面#

    temp(a=100,b=99,c=1000)

    函数调用时,当剩余的参数全部为关键字参数时,可随意定义顺序

    当全部为关键字参数时,调用函数时的参数顺序可随意书写,因为你指定了参数名,但是参数的数量不能少于函数定义时要求的位置参数的数量

    temp(c=100,b=38,a=10)

    也可以使用形如kwarg=value的关键字参数来调用函数。例如下面的函数:

    def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
        print("--This parrot wouldn't",action,end=' ')
        print("if you put",voltage,"volts though it.")
        print("-- Lovely plumage, the", type)
        print("-- It's", state, "!")

    接受一个必需的参数(voltage)和三个可选的参数(state, action,和 type)。这个函数可以通过下面的任何一种方式调用:

    • 一个位置参数:parrot(1000)
    • 一个关键字参数:parrot(voltage=1000)
    • 两个关键字参数;parrot(voltage=1000000, action='VOOOOOM')
    • 两个关键字参数;parrot(action='VOOOOOM', voltage=1000000)
    • 三个位置参数:parrot('a million', 'bereft of life', 'jump')
    • 一个位置参数,一个关键字参数:parrot('a thousand', state='pushing up the daisies')

    但下面的函数调用都是无效的:

    • 丢失必要参数:parrot()
    • 在关键字参数之后的非关键字参数 :parrot(voltage=5.0, 'dead')
    • 同一参数的重复值 :parrot(110, voltage=220)
    • 未知的关键字参数:parrot(actor='John Cleese')

    在函数调用中,关键字参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的其中一个参数匹配(比如 actor 不是函数 parrot 的有效参数),它们的顺序并不重要。这也包括非可选参数,(比如 parrot(voltage=1000) 也是有效的)。不能对同一个参数多次赋值。下面是一个因为此限制而失败的例子:

    def function(a):
        pass
    function(0,a=0)

    关键字参数:**others,便于函数功能的扩展

    当存在一个形式为**name最后一个形参时,它会接收一个字典其中包含除了与已有形参相对应的关键字参数以外的所有关键字参数。这可以与一个形式为*name接收一个包含除了已有形参列表以外的位置参数的元组的形参组合使用(*name必须出现在**name之前,下一小节会讲到)。例如,如果我们这样定义一个函数:

    def cheeseshop(kind, *arguments, **keywords):
        print("-- Do you have any", kind, "?")
        print("-- I'm sorry, we're all out of", kind)
        for arg in arguments:
            print(arg)
        print("-" * 40)
        for kw in keywords:
            print(kw, ":", keywords[kw])

    它可以像这样调用:

    cheeseshop("Limburger", "It's very runny, sir.",
               "It's really very, VERY runny, sir.",
               shopkeeper="Michael Palin",
               client="John Cleese",
               sketch="Cheese Shop Sketch")

    注意打印时关键字参数的顺序保证与调用函数时提供它们的顺序是相匹配的。

    任意的参数列表 *others

    最后,最不常用的选项是可以使用任意数量的参数调用函数。这些参数会被包含在一个元组里。在可变数量的参数之前,可能会出现零个或多个普通参数。:

    def write_multiple_items(file, separator, *args):
        file.write(separator.join(args))

    一般来说,这些可变参数将在形式参数列表的末尾,因为它们收集传递给函数的所有剩余输入参数。出现在*args参数之后的任何形式参数都是‘仅关键字参数’,也就是说它们只能作为关键字参数而不能是位置参数。

    def concat(*args, sep="/"):
       
    return sep.join(args)
    print(concat("earth", "mars", "venus"))
    print(concat("earth", "mars", "venus", sep="."))

    解包参数列表  

    当参数已经在列表或元组中但需要为需要单独位置参数的函数调用解包时,会发生相反的情况。例如,内置的 range() 函数需要单独的 start 和 stop 参数。如果它们不能单独使用,请使用 * 运算符编写函数调用以从列表或元组中解包参数,*args输出结果是3 6:

    list(range(3,6))
    print(list(range(3,6)))
    args=[3,6]
    print(list(range(*args)))

    以同样的方式,字典可以使用 ** 运算符来提供关键字参数:

    def parrot(voltage, state='a stiff', action='voom'):
        print("-- This parrot wouldn't", action, end=' ')
        print("if you put", voltage, "volts through it.", end=' ')
        print("E's", state, "!")
    d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    parrot(**d)

    更多Python框架梳理,请参考: 【Python学习】Python最全总结

     有问题请下方评论,转载请注明出处,并附有原文链接,谢谢!如有侵权,请及时联系。

    展开全文
  • Python中函数定义和实现

    千次阅读 2018-01-02 16:48:03
    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户...

    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

    函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数

    最简单的函数实现,可以敲敲试试,体验一下。

     >>> def FirstFunc():
        print("First Function!")
        print("Life is short,I use Python")

    只要定义过了一个FirstFunc的函数,输入函数名,即可显示函数所要实现的内容。本函数是打印两行话。

    >>> FirstFunc()
    First Function!
    Life is short,I use Python

    可以将这两行话打印若干次,次数自己定。

    >>> for i in range(3):
        FirstFunc()
    
    First Function!
    Life is short,I use Python
    First Function!
    Life is short,I use Python
    First Function!
    Life is short,I use Python
    >>>

    函数的形式十分灵活,可以在函数中间加上关键字,在后面的使用中直接调用,就可以显示不同的名称。

    参数从调用的角度,分为形式参数(parameter)实际参数(argument),形参指的是函数创建和定义过程中小括号里的参数,而实参指的是函数在被调用的过程中传递进来的参数。

    >>> def SecondFunc(name):
        print(name + " is great!")

    括号里的是参数,可以改成任何你想要输出的name。

    >>> SecondFunc("Python")
    Python is great!

    SecondFunc(name)中name是形参,因为只代表一个位置,可以表示任何的变量名;而”Python”则是实参,因为它是一个具体的内容,是赋值到变量名中的值!

    >>> def Func(name,words):
        print(name +'->' +words)

    形参的数量可以不止一个,只要在函数中一一对应即可。

    >>> Func("Hello","Python")
    Hello->Python
    >>> Func(words="Python",name="Hello")
    Hello->Python

    *可以代表全部参数。

    >>> def test(*params):
        print("有%d个参数"%len(params))
        print("第二个参数是:",params[1])

    len(params)显示参数长度,Billep被拆分,输出第二个参数 。

    >>> test('B','i','l','l','e','p')
    有6个参数
    第二个参数是: i
    >>>

    当然,可以同时显示收集参数和位置参数,位置参数默认是最后一位数。

    >>> def test(*params,extra):
        print("收集参数:",params)
        print("位置参数:",extra)

    把extra =8去掉也能达到同样效果。

    >>> test(1,2,3,4,5,6,7,extra =8)
    收集参数: (1, 2, 3, 4, 5, 6, 7)
    位置参数: 8

    当不写return语句的时候,默认Python会认为函数是return none的。

    >>> def hello():
        print("Hello world!")
    >>> print(hello())
    Hello world!
    None
    >>> def hello():
        return("Hello world!")
    >>> print(hello())
    Hello world!

    函数变量的作用域,分为局部变量(Local Variable)和全局变量(Global Variable)。

    >>> def discounts(price,rate):
        final_price = price*rate
        return final_price
    >>> old_price = float(input('请输入原价:'))
    请输入原价:80
    >>> rate = float(input('请输入折扣率:'))
    请输入折扣率:0.6
    >>> new_price = discounts(old_price,rate)
    >>> print('打折后的价格是:',new_price)
    打折后的价格是: 48.0
    >>>

    global关键字,可以在函数中定义全局变量

    >>> count =5
    >>> def func():
        count = 10
        print(count)
    >>> func()
    10
    >>> count
    5
    >>> count =5
    >>> def func():
        global count
        count = 10
        print(count)
    
    >>> func()
    10
    >>> count
    10

    允许在函数内部创建另一个函数,这种函数称为内嵌函数或者内部函数。

    >>> def fun1():
        print("fun1()正在被调用")
        def fun2():
            print("fun2()正在被调用")
        fun2()
    
    >>> fun1()
    fun1()正在被调用
    fun2()正在被调用
    >>>

    闭包(closure)。如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是一个闭包。

    >>> def func(x):
        def funy(y):
            return x*y
        return funy
    >>> i=func(5)
    >>> i(8)
    40

    也可以直接这么写。

    >>> func(5)(8)
    40
    
    >>> def funX():
        x = [5]
        def funY():
            x[0] *=x[0]
            return x[0]
        return funY
    >>> funX()()
    25
    >>>

    nonlocal可以在内部函数中修改外部函数里局部变量的值。

    >>> def funX():
        x = 5
        def funY():
            nonlocal x
            x *=x
            return x
        return funY
    >>> funX()()
    25
    >>>

    lambda表达式

    在我理解,lambda就是随时可定义可用的def,不需要像背一本def的规定,而是一本即用即定义的便利贴

    >>> funX()()
    25
    >>> g = lambda x:2*x+1
    >>> g(4)
    9
    >>> g = lambda x,y:3*x+4*y
    >>> g(3,4)
    25
    >>>

    filter()过滤器,保留你关注的信息,丢掉不关注的信息。

    >>> temp = filter(None,[1,0,2,False,True])
    >>> list(temp)
    [1, 2, True]
    >>> def odd(x):
        return x%2
    >>> temp = filter(odd,range(10))
    >>> list(temp)
    [1, 3, 5, 7, 9]
    >>> 
    >>> list(filter(lambda x:x%2,range(10)))
    [1, 3, 5, 7, 9]

    map()类似“映射”,有两个参数,一个是函数,一个是可迭代序列,可以对这个序列进行加工。

    >>> list(map(lambda x:x*2,range(10)))
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

    一个求阶乘的函数:

    recursion.py
    def recursion(n):
        result = n
        for i in range(1,n):
            result *= i
        return result
    number = int(input('请输入一个整数:'))
    result = recursion(number)
    print("%d的阶乘是:%d"%(number,result))
    RESTART: C:/Users/Administrator/AppData/Local/Programs/Python/Python36/recursion.py 
    请输入一个整数:5
    5的阶乘是:120
    >>>

    递归版本的求阶乘函数:

    def factorial(n):
        if n == 1:
            return 1
        else:
            return n * factorial(n-1)
    number = int(input('请输入一个整数:'))
    result = factorial(number)
    print("%d的阶乘是:%d"%(number,result))
    RESTART: C:/Users/Administrator/AppData/Local/Programs/Python/Python36/recursion.py 
    请输入一个整数:5
    5的阶乘是:120
    >>>

    这里写图片描述

    展开全文
  • 为什么模板函数应该定义在头文件内

    千次阅读 多人点赞 2019-05-23 12:09:02
    首先,C++标准中提到,个编译单元[translation unit]是指个.cpp文件以及它所include的所有.h文件,.h文件里的代码将会被扩展到包含它的.cpp文件里,然后编译器编译该.cpp文件为个.obj文件,但是,不一定能够...
  • python函数定义函数 重点 (Top highlight)No matter what implementation mechanisms programming languages use, all of them have a reserved seat for functions. Functions are essential parts of any code ...
  • python函数

    千次阅读 2021-01-29 03:45:45
    定义函数、调用函数# 函数:组织好的、可重复使用的、用户实现单一或者关联功能的代码段。# 函数能够提高应用的模块性和代码的重复利用率。# Python提供了很多内置的函数,比如len等等,# 另外也可以根据自己的业务...
  • 三元函数(三元函数能几何表示吗)

    千次阅读 2021-02-05 02:49:37
    三元函数可是用二元函数来表示比方说f(x,y,z)=g(x,y)+g(y,z)+g(x,z),但是二元函数是在平面坐标系中表现的,而三元函数就是三维坐标系,这样看在三维坐标系中画个向.那么三元函数表示有什么几何空间意义呢,那么四...
  • MATLAB GUI 全局变量的定义和使用回调函数的更改

    万次阅读 多人点赞 2019-04-28 17:21:58
    个例子 在MATLAB GUI编程中,经常需要处理按钮回调函数之间的一些逻辑。比如,个处理数据的界面,需要先通过按钮,选定数据文件、确定并导入一些数据到程序中,才能点击下个按钮“查看数据”,而如果直接...
  • Python 函数注释

    万次阅读 多人点赞 2017-07-03 19:30:18
    在 Python 3.x 中,增加了特性 - 函数注释(Function Annotations),顾名思义,可做为函数额外的注释来用。 函数注释是个可选功能,它允许在函数参数和返回值中添加任意的元数据。无论是 Python 本身还是...
  • 2、工程未编译或工程清空编译信息后未再进行编译,肯定会跳转不到定义处,这时一般再编译一次工程就可以了。 3、某些寄存器变量,枚举类型或结构体变量。 4、定义的全局变量和局部变量同名(这真是一个程序员不...
  • Matlab画怎么画这个二元函数图像

    千次阅读 2021-04-19 09:07:13
    二元函数可以用mesh或者surf函数画图。1、首先打开matlab。 2、在 matlab 当前目录空间右键。 3、然后点击 new -> M-File。 4、然后将文件命令为hello.m。 5、然后双击该文件,输入[Rm dm]=meshgrid(15:5:50,1:10...
  • QT一次信号触发多次槽函数的情况

    千次阅读 2020-04-24 15:35:24
    代码片段如下: void MainWidget::slt_ShowSetupWidget() { int res; setup = new Setup; res = setup->...setup是MainWidget类中定义为私有成员的 private: Setup *setup; 老代码是: void MainWidget::s...
  • 函数的声明、定义和调用 函数:提高可读性。实现多个功能,只需对每个功能编写程序,主程序调用所写程序即可。 以这个问题为例: 函数声明(有分号): status ReadInfo(char *name, struct student stu[], int...
  • Python学习:自定义函数,不可或缺

    千次阅读 2020-09-03 17:26:46
    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户...
  • 在开发程序时,需要某块代码多,为了提高编写效率以及代码块的重用性,所以把具有相同独立功能的代码块组织为个小模块,并且给这个功能个名称,这就是函数。 2.定义函数 语法 def 函数名([参数列表]): #...
  • f是定义好的关系,可以简称为函数,在函数f中,只要x值的确定,那么y的值一定是确定的。y的值随x值的变化而变化。 1.2 Python中的函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 ...
  • 1.函数接口说明 在C++中指定函数接口时,一些必须要解决的问题有: (1) 运算符函数还是非运算符函数? (2) 自由运算符还是成员运算符? (3) 虚函数还是非虚函数? (4) 纯虚成员函数还是非纯虚成员函数? (5) ...
  • python基础-函数

    千次阅读 2021-01-14 14:40:44
    函数的基本使用函数的参数详解名称空间与作用域闭包函数装饰器2020.9.11小白学习,如有错误欢迎指点参考自egon大佬Python快速入门神器​www.zhihu.com函数使用函数的原因:所有功能的实现代码堆叠在一起,导致代码的...
  • 在C ++ STL中设置count()函数

    千次阅读 2021-05-22 00:59:30
    在本文中,我们将讨论C ++ STL中的set::count,它们的语法,工作方式以及它们的返回值。C ++ STL中的设置是什么?C ++ STL中的集合是必须按常规顺序具有唯一元素的容器。集必须具有唯一元素,...count()函数是C ++ ...
  • JS函数详解

    万次阅读 多人点赞 2019-07-10 22:56:56
    2.函数表达式(匿名函数) 3.函数传参 4.修改input的值 5.函数的不定参(可变参)—关键字arguments 6.函数返回值 7.封装获取元素的方法 8.获取计算后样式—getComputedStyle(el) 8.JS预解析机制(变量提升...
  • mul函数的具体用法

    千次阅读 2020-12-18 02:53:07
    展开全部PHP基础Author:陈庆平 (Andych)E-mail:ahut9923@126.com、PHP入门二、PHP变量62616964757a686964616fe4b893e5b19e313332623836391、php变量的命名变量由字母,数字,下划线组成1)变量名区分大小写2)变量名...
  • 深入浅出C语言:(四)函数

    千次阅读 2019-10-01 14:44:03
    函数调用详解(从中发现程序运行的秘密) 二、函数声明以及函数原型 三、全局变量和局部变量 四、C 语言变量的作用域 五、C 语言块级变量(在代码块内部定义的变量) 六、再谈作用域 七、C 语言递归函数...
  • 3 参数 1) 传递参数 2)参数匹配法则 3) 任意参数——收集参数,解包参数,Keyword-Only参数 函数:将一些语句集合在一起的部件,能够不止一次地在程序中运行。具体来说,函数能够计算出一个返回值,并能够改变...
  • C++--回调函数与接口定义规范

    千次阅读 2016-11-14 09:56:13
    概述:接口及设计目标,目的是避免改动接口,让程序初始化一次,就达到准备工作的状态,其他实现在运行中控制内容。 1、接口,命名要能看出来这个接口的作用。不需要在写fun等标识。  例如;FindKeyWordCount,就...
  • html 函数

    千次阅读 2018-10-25 09:21:05
    函数(function) 、概要 函数为程序设计人员提供了个丰常方便的能力。通常在进行个复杂的程序设计时,总是根据所要完成的功能,将程序划分为一些相对独立的...从而实现函数把它与事件驱动相关联。这是与其...
  • 在脚本回放过程中,客户端发出请求,通过关联函数定义的左右边界值(也就是关联规则),在服务器所响应的内容中查找,得到相应的值,已变量的形式替换录制时的静态值,从而向服务器发出正确的请求,这种动态获得...
  • 哈希函数

    万次阅读 多人点赞 2018-03-01 08:12:14
    在某种程度上,散列是与排序相反的种操作,排序是将集合中的元素按照某种方式比如字典顺序排列在一起,而散列通过计算哈希值,打破元素之间原有的关系,使集合中的元素按照散列函数的分类进行排列。在介绍一些集合...
  • 本文章主要总结在Qt5.9Creator中自定义个信号,然后在另个类里面用该信号触发槽函数的实例。具体的实例是在类ClassA中自定义个信号Signal1,然后在MAinWindows类中用该信号Signal1来触发槽函数SlotFunction()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 343,200
精华内容 137,280
关键字:

一次函数新定义关联函数