Day11

总结

函数的定义、调用

1.函数定义调用遵循顺序原则，先定义再调用
2.函数体代码在定义时不会执行，定义时只会检测语法，调用函数时才会执行代码
# 定义函数
def func():
    print('')
# 调用函数
func()

函数的分类

1.内置函数
	函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2.自定义函数
	自己编写的函数
    1.无参函数
    	无参数函数的函数名后面的括号里是空的，没有参数列表。有时，也在括号里面形式地写上void，表示没有参数
    2.有参函数
    	在函数定义阶段括号内有参数，分为形参和实参
         形参是定义函数时在括号里定义的变量，它只是申明用的，没有值
		实参是调用函数时传给形参的值，有值
    3.空函数
    	在定义阶段函数体代码是无实意
        '''
        	空函数大量的使用在项目前期的功能框架搭建，前期能够通过空函数快速的罗列出程序中大致的功能让程序整体框架清晰  
        '''       

函数的返回值

函数的返回值其实就是在调用函数之后返回的结果
	1.当函数体代码没有return是，返回值是none
    def index():
    	print('Hello world')
    res = index()
    print(res)  # None
    2.当函数体代码写了return但是没有跟任何值得时候 返回值也是none
    def index():
    	print('Hello world')
        return
    res = index()
    print(res)  # None
	3.当函数体代码写了return并且跟了数据  就返回写的值
    	如果写的是值那么直接返回值
    	如果写的是变量名那么返回变量名指向的值
        def index():
            print('Hello world')
            user = 'jack'
            return user
        res = index()
        print(res)  # user
    4.return后面还可以跟多个值,会自动组织成元组返回出去
		 def index():
            print('Hello world')
            user = 'jack'
            return user, 1, 2
        res = index()
        print(res)  # ('jack', 1, 2)
    5.函数体代码遇到return会立刻结束函数运行

函数的参数

函数的参数可以分为两大类
	形参与实参
    形参类似于变量名，实参类似于变量值
	# 形参是定义函数时在括号里定义的变量，它只是申明用的，没有值
	# 实参是调用函数时传给形参的值，有值
    # 在调用函数是传入的实参会与形参绑定，函数运行结束会自动解除绑定
    
    def func(m,n):  # 形参
    	print(m,n)
    func(11,22) # 实参
    

位置参数

1.位置形参
	定义函数时填写的变量名
    def func(m,n):
        pass
2.位置实参
	调用函数时填写的数据
    
# 位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
# 位置形参与位置实参的个数必须一致

def func(m,n):  
    	print(m,n)
    func(1,2) # 传参
    func(1)   # 传少了，报错
    func(1,2,3)  # 传多了，报错

关键字参数

可以将实参的值通过关键字来指定给具体给哪个形参
    def fun1(a, b):
        print(a, b)

    fun1(b=1, a=2)
    func(b=2, 1)  # 报错，关键字参数必须放在位置参数后边
    func(1, a=1)  # 报错，形参只能指向一个实参

默认参数

在定义时，形参如果给出了默认值，这时候，就是默认参数。 所有的默认参数必修放在最后，默认参数在调用时，如果没有实参对他进行赋值，他的值为默认值，否则为指定值
	def fun1(a, b, c=3):
    print(a, b, c)


    fun1(1, 2)  # 不传就使用默认的
    fun1(1, 2, 4)  # 传了值则使用传入的值

可变长参数

含义:在调用函数时，传入的参数个数可以不固定
    def func(*a):
    	print(a)
    func()  # ()
    func(1,2)  # (1, 2)
    func(1,2,3,4,5,6)  # (1, 2, 3, 4, 5, 6)
    
    def func(a, b, **c):
        print(a, b, c)
    func(a=1, b=2)  # 1 2 {}
    func(a=1, b=2, c=3, str='abc')  # 1 2 {'c': 3, 'str': 'abc'}
    
'''
	*号在形参中可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
	**在形参中用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
'''

可变长形参

# 形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给后的参数。
# 形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给后的参数。
def func(*args, **kwargs):
    print(args, kwargs)


func(1, 2, a=3, b=4, c='abc')  # (1, 2) {'a': 3, 'b': 4, 'c': 'abc'}


# 需要注意的是：*后的参数名约定俗成为args,**后的参数名约定俗成为kwargs。
	def index(*args, **kwargs):
    pass

*与**在实参中的使用

# 实参中的*，会将后参数的值循环取出，打散成位置实参
# 实参中的**，会将后参数的值循环取出，打散成关键字实参。
def func(*args, **kwargs):
    print(args, kwargs)
   
func(1, 2, 3, 4, name='jack', gender='male', age=19)  # (1, 2, 3, 4) {'name': 'jack', 'gender': 'male', 'age': 19}

def index(*[11,22,33])  等价于 index(11,22,33)
def index(*(11,22,33))  等价于 index(11,22,33)
可以理解成*号会去除列表和元组的括号，拿出一个个元素

今天学了参数，对参数有了更全面的认识
: