函数，形参与实参

本章内容

• 函数的定义与调用
• 函数的分类
• 函数的返回值
• 函数的参数

函数的定义与调用

"""
函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。
"""
# 1. 函数一定要遵循先定义再调用的原则
# 2. 函数在定义阶段只检测语法不执行代码
# 3. 函数体代码只有在调用函数的时候才会执行
# 4. 函数名其实相当于是变量名指向的是内存中函数体代码所在的位置
eg :
    定义函数：
    def func():
        print('hello world')
    调用函数：
    func()   # hello world

函数的分类

1.内置函数
    python解释器提前定义好可以直接调用的函数
    eg: len、open...  # 查看代码的内部源码 >>>>> ctrl+左键
2.自定义函数
    1.1 自己编写的函数
    2.1 无参函数
    2.3 空函数
# 1. 无参函数：在函数定义阶段括号内没有参数
# def index():
#    print('python是最牛逼的')
# 调用无参函数时括号内也不需要写参数
# index()

# 2. 有参函数：在函数定义阶段时括号内有参数>>>:类似于变量名
# def index(a):
#      print('python是最牛逼的',a)
# 调用有参函数:在函数调用阶段括号内也必须传参数>>>:类似于变量值
# index(666)

# 3.空函数：在定义阶段函数体代码用pass或者...占位
# def func():
#     pass
"""
定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。
"""

函数的返回值

# 函数的返回值其实就是函数被调用后返回的结果
# 获取函数的返回值
	变量名 = 函数调用
# 如何操作返回值
	1.当函数体代码没有return关键字的时候，返回值是None
    eg:
    	def func():
    		print('你他喵的，哈哈哈！！！')
		s = func()
		print(s)

 2. 当函数体代码写了return但是没有跟任何值得时候 返回值也是None
    	def func():
    	     print('你他喵的，哈哈哈！！！')
             return
	s = func()
	print(s)

3.当函数体代码写了return并且跟了数据 那么写什么就返回什么
  	如果写的是值那么直接返回值(任意数据类型)
    如果写的是变量名那么返回变量名指向的值
eg:
    def func():
    	name = 'jerry'
    	return name
	s = func()
	print(s)		

4.return后面还可以跟多个值 逗号隔开  会自动组织成元组返回出去后
eg:
    def func():
    	print('python是最牛逼的语言')
    	name = 'jerry'
    	name2 = 'kevin'
    	return name,name2,18,19
	s = func()
	print(s)

5.函数体代码遇到return会立刻结束函数运行
  函数体代码里面写return相当于循环体代码里面写break
  遇到了就立刻结束函数和循环的执行

函数的参数

1.函数的参数可以分为两大类
    1.函数在定义阶段括号内写的参数
    	我们称之为'形式参数'，简称为>>>>>:形参
    2.函数在调用阶段括号内写的参数
    	我们称之为'实际参数'，简称为>>>>>:实参
2.形参与实参的关系
    形参类似于是变量名、实参类似于是变量的值
    在调用函数的时候传入实参 会与形参临时绑定
    函数运行结束之后自动结束绑定
	eg:
        def func(a,b):
    	    print(a,b)
            return 0
        func('jason',18)    

位置参数

位置形参：
    在函数的定义中，括号内依次从左往右写上变量名
    def func(name,age,gender):   # 这里的name,age,gender就是位置形参
    	print(f'他叫{name}，{age}岁了，性别是{gender}')
    	return 666
位置实参：
    func('jason',18,'male')     # 这里的jaosn,18,male就是位置实参
    
位置参数的特征：
	1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
    2.位置形参与位置实参的个数要一致 # 多一个不行少一个也不行
    
    eg:
        func('jason',18,'male')   # 正确
	func()                    # 报错
	func('jason',18)          # 报错
	func('jason',19,'male',182)  # 报错

关键字参数

出现在实参中
	指名道姓的给形参传值 不需要遵循位置
    def func(name,age,gender):   
    	print(f'他叫{name}，{age}岁了，性别是{gender}')
    	return 666
    func(name = 'jason',age = 18,gender = 'male')    # 关键字参数
    func('tony',name='jason',gender='male')        # 报错 形参只能指向一个实参
	func(name='jerry',age=18,'male')     # 报错 位置参数必须在关键字参数前面
	func('jason',19,gender='male')      # 正确

默认参数

出现在形参中
	在函数定义阶段就已经给一些形参赋值了 
  	后续如果不传值则使用默认的
        后续如果传值则使用传入的
	默认参数的出现也打破了形参与实参之间个数一致的情况
  默认参数必须定义在位置参数的后面  # 至于顺序问题 后面有口诀
eg:
    def func(name,age,gender='male'):
   	print(f'他叫{name}，{age}岁了，性别是{gender}')
    	return 666
    func('jason',19,)
    func(name='tony',age=20)
    func('jerry',20,'remale')

可变长参数(重要)

需求：定义一个函数，无论传多少位置实参都可以正常执行
	类似于print
    def func(*a):
    	print(a)
    func()                         # ()
    func(1)                        # (1,)
    func(1,2)                      # (1, 2)
    func(1,2,3,4,5,6,6)            # (1, 2, 3, 4, 5, 6, 6)
    
# *号在形参中
    #可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
    eg:
         def func(a, b, *s):
    	      print(a, b, s)
         func(1)                    # 报错，至少要传两个参数a和b
	 func(1,2)                  # 1 2 ()
	 func(1,2,3)                # 1 2 (3,)
	 func(1,2,3,4)              # 1 2 (3, 4)
        
        
# **在形参中
    # 用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
    eg:
        def index(a, b, **k):
    	    print(a, b, k)
	index(a=1, b=2)  # 1 2 {}
	index(a=1, b=2, c=3, name='jason')  # 1 2 {'c': 3, 'name': 'jason'}
	index(1,2,name='jason',age=18,pwd=123)  # 1 2 {'name': 'jason', 'age': 18, 'pwd': 123}
'''需求:定义一个函数 无论传入多少关键字参数都可以正常执行'''
		def func(**k):
    		    print(k)
		func()  # {}
		func(a=1,b=2)  # {'a': 1, 'b': 2}
		func(a=1,b=2,c=3,d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

可变长形参

"""
思考题:如何定义一个无论接收多少个任意类型的参数都可以正常执行的函数
"""
    def func(*a,**k):
        print(a,k)
    func()  # () {}
    func(1,2,3,4,name='jason',age=18)  # (1, 2, 3, 4) {'name': 'jason', 'age': 18}
    
# 以后在定义函数的时候 如果不确定这个函数将来需要多个实参 那么可以采用上述的方法

"""*和**在形参中的使用 后面的变量名并不是关键 但是针对这两个特殊符号后面的变量名 有推荐的写法"""

    def index(*args, **kwargs):
        pass

补充说明

*和**不单单可以在形参中使用 还可以在实参中使用
def index(*args, **kwargs):
    print(args, kwargs)
 
"""
 *号在实参中 
    可以将列表或者元组打散成位置参数一一传入
"""   
def func(*args, **kwargs):
    print(args, kwargs)
func(*[1, 2, 3, 4, 5, 6])          # (1, 2, 3, 4, 5, 6) {}
func(*(1, 2, 3, 4, 5, 6))          # (1, 2, 3, 4, 5, 6) {}
func([1, 2, 3, 4, 5, 6])           # ([1, 2, 3, 4, 5, 6],) {}

"""
**号在实参中
    可以将字典打散成关键字参数一一传入
"""
def func(*args, **kwargs):
    print(args, kwargs)
func(**{'name': 'jason', 'name2': 'tony', 'name3': 'jerry'})
# () {'name': 'jason', 'name2': 'tony', 'name3': 'jerry'}
func({'name': 'jason', 'name2': 'tony', 'name3': 'jerry'})
# ({'name': 'jason', 'name2': 'tony', 'name3': 'jerry'},) {}