函数

3、函数的参数

1）参数的种类:
(1) 形参: 形式上的参数 , 在函数的定义处
(2) 实参: 实际上的参数 , 在函数的调用处

2）形参的种类:
普通(位置)形参,默认形参,普通收集参数,命名关键字参数,关键字收集参数
注：调用时,如果不给实际参数,默认使用自带的值进行调用
调用时,如果给实际参数,那么使用实参来进行调用
默认参数必须跟在普通参数的后面
调用函数时,关键字实参顺序可以任意调整的
关键字实参必须跟在普通实参的身后

​ 收集参数：

​ 普通收集参数：通过*加参数代表普通收集参数，收集多余的没人要的普通实参构成元组的形式。

​ def func(*args):
​ pass
​ args => arguments(参数)

​ 关键字收集参数：通过**加参数代表关键字收集参数，收集多余的关键字实参构成字典的形式

​ def func(**kwargs):
​ pass
​ kwargs = keyword arguments

​ 命名关键字参数：使用方式 def 函数名(参数1，参数2，*， 参数3，…)

​ 关键字参数的两种存在形式：

​ （1）在*号后面定义的形如普通参数的参数是关键字参数

​ （2）在普通收集和关键字收集参数之间的，是命名关键字参数

​ 注： 命名关键字参数必须使用关键字实参的形式调用；

3）实参的种类:
普通实参,关键字实参

4）遵循的原则:
调用参数的时,形参和实参必须一一对应,否则报错

5）区分默认形参和关键字实参

​ 默认形参：

​ 关键字形参：

6）关于 * 和 ** 的使用方法

​ 在函数的定义处，*和**用来接受数据，*将接受到的数据打包成一个元组，**将接受到的数据打包成一个字典

​ 在函数的调用处，*和**用来解包数据，*一般应用在列表或元组，**一般用在字典

​ *和**的优点：控制了参数的个数

# 普通形参
def star(hang,lie):
	i = 0
	while i<hang:
		j = 0
		while j<lie:
			print("*",end="")
			j+=1
		print()
		i+=1
# 普通实参
star(4,9)

# 默认形参
def star(hang=10,lie=10):
	i = 0
	while i<hang:
		j = 0
		while j<lie:
			print("*",end="")
			j+=1
		print()
		i+=1
star()

# 普通形参 + 默认形参
""""""
def star(hang,lie=10):
	i = 0
	while i<hang:
		j = 0
		while j<lie:
			print("*",end="")
			j+=1
		print()
		i+=1

star(20)

# 关键字实参
def star(hang,lie=10):
	i = 0
	while i<hang:
		j = 0
		while j<lie:
			print("*",end="")
			j+=1
		print()
		i+=1

# 关键字实参
star(hang=3,lie=8)
star(lie=8,hang=3)


# 普通实参 + 关键字实参
def star(hang,a,b,c,lie=10):
	i = 0
	while i<hang:
		j = 0
		while j<lie:
			print("*",end="")
			j+=1
		print()
		i+=1
star(3,3,4,5,lie=4)

# 普通收集参数
def mysum(*args):
    total = 0
    for i in args:
        total += i
    print(total)
mysum(1, 2, 3, 4)

# 关键字收集参数
def func(**kwargs):
    strvar = ""
    strvar2 = ""
    dic = {'a': 'b', 'c': 'd', 'e': 'f'}
    for k, v in kwargs.items():
        if k in dic:
            strvar += k + ":" + v + "\n"
        else:
            strvar2 += v + ","
    print(strvar.strip())
    print("吃瓜群众：" + strvar2.strip(",") + "......")
func(a = "b", c = "d")

# 命名关键字参数
# 定义方式一
def func(a, b, *, c):
    print(a, b)
    print(c)
func(1, 2, c=3)

# 定义方式二
def func(*args, dd, **kwargs):
    print(args)
    print(kwargs)
    print(dd)
func(1, 2, 3, dd=5, a=1, b=2)

# *和**
def func(a, b, *, c, d):
    print(a, b)
    print(c, d)
# *打包和**打包类似
func(1, 2, c=3, d=4)
lst = [1, 2]
# *解包
func(*lst, c=3, d=4)
# **解包
dic = {"c": 3, "d": 4}
func(1, 2, **dic)

4、return自定义返回值

​ 函数可以自定义返回值，通过return把值返回导函数的调用处

​ （1）return + 返回值：可以接六大标准数据类型、返回函数和类对象，未定义返回值，默认返回None

​ （2）函数中若执行了return，就会终止函数，return后面的代码块将不会再被执行

​ 注：未定义返回值，默认返回None，函数执行到return立刻终止函数

def func():
    return 100
ret=func()
print(ret) 

5、全局变量和局部变量

（1）局部变量：在函数内部定义的变量就是局部变量（局部命名空间）

（2）全局变量：在函数外面定义的变量 或者 在函数内部用global关键字定义是全局变量 (全局命名空间)

​ global：函数内部定义全局变量使用global

（3）作用域：

​ 局部变量作用域：限定在本层函数的内部

​ 全局变量作用域：横跨整个文件

（4）生命周期：

​ 内置命名空间>全局命名空间>局部命名空间

​ 内置变量>全局变量>局部变量

i = 0  # i是一个全局变量
def func():
	a = 1  # a是一个局部变量
	print(a)
	a = 20
	print(a)
	# global i  # 使用global声明后才可修改全局变量i
	i = 2  # 不会修改全局变量的值
print(a)  # 不能获取局部变量的值
print(i)

6、函数名的使用

python中的函数可以像变量一样，动态创建，销毁，当参数传递，作为返回值,叫做第一类对象,其他语言不具备

函数名的四种使用方法

（1）函数名当作变量赋值

def func1():
	print("我是func1")
	return 111
res = func1()
print(res)

（2）函数名可以作为容器类型数据的元素

def func2():
	print("我是func2")
def func3():
	print("我是func3")
def func4():
	print("我是func4")	
	return "func4"
lst = [func2,func3,func4]
for i in lst:
	i()

（3）函数名可以作为函数的参数

def func4():
	print("我是func4")	
	return "func4"
def myfunc(f):
	res = f()
	print(res)
myfunc(func4)

（4）函数名可以作为函数的返回值

def myfunc2(f):
	return f
f2 = myfunc2(func4)
print(f2)
f2()

__doc__或者help查看文档（获取注释的内容，查看帮助文档）

def eat_big_chang(something):
	'''
	说明注释
	'''
	print("step1=>先把{}洗一洗".format(something))
res = eat_big_chang("a")
print(res)
print(eat_big_chang.__doc__)
print(help(eat_big_chang))