Java教程

函数的本质、语法结构、返回值、参数

本文主要是介绍函数的本质、语法结构、返回值、参数,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

函数的本质

函数可以看作是一个工具,提前定义好,之后就可以反复使用,没有函数(相当于没有工具) 那么需要用的时候得现场制作,有函数(相当于有工具) 那么需要的时候直接调用(使用)即可

1.函数的定义(提前准备工具的过程)
    def my_func():
        pass
2.函数的使用(开始选择工具事物时候)--调用函数,函数调用
	my_func()  

函数的语法结构

def 函数名(参数1,参数2...):
    """函数注释"""
    函数体代码
    return 返回值
1.def:是定义函数的关键字
2.函数名:与变量名的命名一致,尽量做到见名知意
3.括号:在定义函数的时候函数名后面必须跟括号
4.参数:定义函数括号内可以写参数(没有固定的个数),也可以不写参数
	   用于接收外界传递给函数体代码的内部数据
5.函数注释:(可以不写)类似于说明书,用于介绍函数的主题功能和具体用法,增强函数的可读性
6.函数体代码:整个函数最核心的区域(逻辑代码)
7.return:控制函数的返回值,return可有可无

函数的定义与调用

1.函数必须先定义后调用
	定义函数的代码必须要在调用函数的代码之前先运行
2.定义函数使用def关键字,调用函数使用函数名加括号(可能需要添加额外的参数)
3.函数在定义阶段只检测函数体代码语法,不执行函数体代码,只有在调用阶段才会真正的执行函数体代码
4.函数名本质:函数名绑定的是一块内存地址 里面存放了函数体代码
			如果想要运行代码,就需要调用函数>>>;函数名加括号(执行优先级最高,定义阶段除外)

函数的分类

函数分为内置函数和自定义函数,自定义函数包括空函数、无参函数、有参函数

1.内置函数:解释器提前帮你定义好函数,用户可以直接使用 eg: len()
  ps:内置函数可以直接调用,但是数据类型的内置方法(函数)必须使用数据类型点的方式才可以调用,相当于是数据类型独有的一些内置方法 eg:  str.strip()
2.自定义函数
	2.1 空函数:函数体代码使用pass顶替,暂时没有任何功能,主要用于前期项目搭建,提示主要功能
	2.2 无参函数:函数在定义阶段括号内没有填写参数
    	eg:
		def func():
            print("from func")
    2.3 有参函数:函数在定义阶段括号内有填写参数
        ps:有参函数在调用时,需要函数名加括号并且给数据值
        def func(a,b):
            print(a)
            print(b)

        func(1,2)  # 1 2 
        func()  # 报错

函数的返回值

返回值就是调用函数之后产生的结果,可有可无

获取函数返回值的方式:
    变量名 = 函数名() 
    print(变量名)  # 有则获取 没有则默认接收None
1.函数体代码没有return关键字:默认返回None
  eg:
    def func():
        print('from func')
    res = func()  # from func
    print(res)  # None	
2.函数体代码有return关键字:后面不写,也返回None
  eg:
	def func():
    	print('from func')
    	return
	res = func()  # from func
	print(res)  # None
3.函数体代码有return关键字:return后面写什么就返回什么(如果是数据值则直接返回,如果是变量则需要找到对应的数据值返回)
  eg:
	def func():
        print('from func')
        return 1
    res = func()  # from func
    print(res)  # 1
    
    def func():
        print('from func')
        return name
    name = 'nana'
    res = func()  # from func
	print(res)  # nana

    def func():
        name = 'nana'
        print('from func')
        return name
    res = func()  # from func
    print(res)  # nana
    
4.函数体代码有return关键字,并且后面写了多个数据值(名字)
  用逗号隔开:默认情况下会自动组织成元组返回
  eg:
	def func():
        print('from func')
        return 1,2,3,4,5
    res = func()  # from func
    print(res)  # (1, 2, 3, 4, 5)
    
	def func():
        print('from func')
        return {'name':'nana'}
    res = func()  # from func
    print(res)  # {'name': 'nana'}
5.函数体代码遇到return关键字会立刻结束函数体代码的运行
  eg:
	def func():
        print('上面')
        return {'name':'nana'}
        print('下面')
    res = func()  # 上面
    print(res)  # {'name': 'nana'}
	

函数的参数

参数有两大类:形式参数和实际参数。在形参和实参使用中,又出现了位置参数(包括位置形参,位置实参)、关键字参数(关键字实参)、默认值参数(默认值形参)、可变长参数(可变长形参)

形式参数与实际参数

1.形式参数(形参):函数在定义阶段括号内填写的参数 
2.实际参数(实参):函数在调用阶段括号内填写的参数
3.形参与实参的关系:
	3.1 形参相当于变量名,实参相当于数据值
	3.2 在函数调用阶段形参会临时与实参进行绑定,函数运行结束会立刻解除  >>>动态绑定 动态解除
    eg:
    def func(a,b,c):    
        print(a)
        print(b)
        print(c)
    func(1,2,3)  # 1 2 3
    func('na','1','xiao')  # na 1 xiao 

位置参数

1.位置形参:在函数定义阶段括号内从左往右依次填写的变量名称之为位置形参
2.位置实参:在函数调用阶段括号内从左往右依次填写的数据值称之为位置实参
ps:
  1.实参可以是数据值也可以是绑定了数据值得变量名
	eg:
    def func(a,b,c):
        print(a)
        print(b)
        print(c)
    func(1,2,3)  # 1 2 3
    
    def func(a,b,c):
        print(a)
        print(b)
        print(c)
    name = 'nan'
    age = 12
    func(name,age,3)  # nan 12 3
    
  2.位置实参给位置形参传值时,必须个数一致,多一个不行,少一个也不行
	eg:
	def func(a,b,c):
        print(a)
        print(b)
        print(c)
    func()  # 报错
    func(1)  # 报错
    func(1,2)  # 报错
    func(1,2,3)  # 1,2,3
    func(1,2,3,4)  # 报错

关键字参数

关键字参数也叫做关键字实参:在函数调用阶段括号内,以什么等于什么的形式传值称之为关键字实参
ps:
  1.指名道姓的给形参传值(打破了位置的限制)
	eg:
    def func(a,b,c):
        print(a)
        print(b)
        print(c)
    func(b=1,a=2,c=3)  # 2 1 3

  2.位置实参必须在关键字实参的前面(无论时形参还是实参,都遵循短的(简单)在前面,长的(复杂)在后面)
	eg:
	def func(a,b,c):
		print(a)
		print(b)
		print(c)
	func(b=1,a=2,4)   # 报错 positional argument follows keyword argument
    
    def func(a,b,c):
        print(a)
        print(b)
        print(c)
    func(1,c=2,b=4)  # 1 4 2
  3.同一个形参在一次调用中只能传一次值 
	eg:
	def func(a,b,c):
        print(a)
        print(b)
        print(c)
    func(2,a=1,c=4)  # 报错 func() got multiple values for argument 'a'

默认值参数

默认值参数(默认值形参):在函数定义阶段内,以什么等于什么的形式填写的形参称之为默认值形参
ps:
  1.在函数定义阶段就给形参绑定值,后续调用阶段就可以不传
	eg:
	def func(name,age,gender='man'):
        print(f"""
        ==========================
        姓名:{name}
        年龄:{age}
        性别:{gender}
        ==========================
        """)
    func('xiao',18)
    结果:
    ==========================
    姓名:xiao
    年龄:18
    性别:man
    ==========================

  2.调用阶段不传值就使用默认的,传了值的就用传了的
	eg:
     func('nana',18,'woman')
    结果:
	==========================
    姓名:nana
    年龄:18
    性别:woman
    ==========================
  3.还需要注意的是,位置实参必须在关键字实参的前面(无论时形参还是实参,都遵循短的(简单)在前面,长的(复杂)在后面)

可变长参数

可变长参数:可以打破形参与实参的个数限制,随意传值  
1.定义一个函数,无论接收多少位置的实参,都可以执行
  eg:
  def func(*x):
    print(x)
  func()  # ()
  func(1)  # (1,)
  func(1,[1,2])  # (1,[1,2])
  func(1,2,3,4)  # (1,2,3,4)
  ps:'*'在形参中的作用:接收多余的位置参数,并组织成元组的形式赋值给*后面的变量名
2.定义一个函数,无论接收多少关键字实参,都可以执行
  eg:
	def func(**y):
		print(x)
	func()  # {}
    func(name='nana')  # {'name': 'nana'}
    func(name='nana',age =18)  # {’name':'nana','age':18}
    func(name='nana',age =18,gender ='women')  # {’name':'nana','age':18,'gender':'women} 
  ps:'**'在形参中的作用:接收多余的关键字参数并组织成字典的形式赋值给**后面的变量名  
3.能够定义一个函数,无论怎么传值都可以执行
  eg:
	def func(*x,**y):
        print(x)
        print(y)

    func()  # () {}
    func(1)  # (1,) {}
    func(b=3)  # () {'b':3}
    func(1,b=2)  # (1,) {'b':2}
    func(1,2,3,b=1,d=2)  # (1,2,3) {'b':1,'d':2}
4.可变长的位置参数(*args)、可变长的关键字参数(**args)
	def func(*args,**args):
        pass
    
这篇关于函数的本质、语法结构、返回值、参数的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!