python学习 day10

收集参数

(1) 普通收集参数 :

• 在参数的前面加上一个*,代表的是普通收集参数.
  作用:收集多余的没人要的普通实参,构成一个元组
  如果对应实参为空，则输出空元组。

格式：

def func(*args):
	pass

args => arguments(参数)
示例:

def func(a,b,c,*args):
	print(a,b,c)		# 1,2,3
	print(args)			# (4,5,6,7,8)

func(1,2,3,4,5,6,7,8)

案例：计算任意个数的累加和

def mysum(*args):	# 利用普通收集参数将数量不限的参数收入其中打包成元组
	total = 0
	for i in args:	# 将元组遍历后相加输出合
		total += i
	print(total)
mysum(1,2,3,4,5,6,7,8,9,1111)	# 优点：参数不限数量

(2) 关键字收集参数

• 在参数的前面加上两个*,代表的是关键字收集参数
  作用:收集多余的没人要的关键字实参,构成一个字典
  如果对应实参为空，则输出空字典。

格式：

def func(**kwargs):
	pass

kwargs => keyword arguments(关键字参数)
示例：

def func(a=1,b=2,c=3,**kwargs):
	print(a,b,c)
	print(kwargs)

func(a=4,b=5,c=6,f=1,z=2,x=3)	# 4 5 6\n{'f':1,'z':2,'x':3}
func(4,5,6,f=1,z=2,x=3)			# 4 5 6\n{'f':1,'z':2,'x':3}

案例：任意字符串的拼接
预期效果：

班长:张恒
班花:刘思敏
吃瓜群众:黄俊,王振...

代码：

def func(**kwargs):
	strvar = ""
	strvar2 = ""
	dic = {"monitor":"班长","class_flower":"班花"}
	for k,v in kwargs.items():	# 遍历元组
		# print(k,v)
		# 判断键在字典中,在进行获取
		if k in dic:
			strvar += dic[k] + ":" + v	+ "\n"		
		# 如果不在,那就是吃瓜群众
		else:
			strvar2 += v + " , "
	print(strvar.strip())
	print("吃瓜群众:" + strvar2.strip(" , ") + "......")
func(monitor="张恒",class_flower="刘思敏",hj="黄俊",wz="王振")

参数的顺序：

形参顺序:

• 普通形参 -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数

命名关键字参数

def func(参数1,参数2,*,参数3)

• (1) 在*号后面定义的参数只能是命名关键字参数，实参导入星号时会报错

def func(*args,命名关键字参数,**kwargs)

• (2) 在普通收集 和关键字收集参数之间的,只能是命名关键字参数

如果是命名关键字参数,必须使用关键字实参的形式调用;

(1) 定义方式一

跳过*号导入实参：

def func(a,b,*,c):
	print(a,b)
	print(c)
	
# 函数的调用处
func(1,2,c=3)

(2) 定义方式二

在普通收集 和关键字收集参数之间的,只能是命名关键字参数：

def func(*args,dd,**kwargs):
	print(args)
	print(kwargs)
	print(dd)
func(1,2,3,4,4,5,6,a=1,b=2,c=3,dd="abc")

关于 * 和 ** 的使用方法

• 在函数的定义处, * 和 ** 用来接收数据,*打包成一个元组,**打包成个字典
  在函数的调用处, * 和 ** 用来解包数据,*一般应用在列表或元组,**一般用在字典

* 一个星调用处的语法

*lst <=> 把列表里面的每一个元素都单独拿出来,当成参数赋值给func进行调用：

def func(a,b,*,c,d):
	print(a,b)
	print(c,d)
lst = [1,2]
func(*lst,c=3,d=4)	# 等同于func(1,2,c=3,d=4)

** 二个星调用处的语法

**dic <=> 把字典里面的键值对拿出来,转化成关键字实参的形式,当成参数赋值给func进行调用：

def func(a,b,*,c,d):
	print(a,b)
	print(c,d)
dic = {"c":3,"d":4}
func(1,2,**dic)		# 等同于(1,2,c=3,d=4)

收集所有实参

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

小结

定义处的号用法 和 调用处的号用法 是一对相反操作
一个是用来打包,一个是用来解包
优点:控制了参数的个数.
“定义处对应输入的是形参，调用出对应输入的是实参。”

return 自定义返回值

函数可以自定义返回值,通过return ,return会把这个值返回到函数的调用处

• (1) return + 返回值 后面除了可以接6大标准数据类型之外,还可以返回函数和类对象,
  如果没有定义任何返回值,默认返回的是None

• (2) 在函数中,如果执行了return , 意味着立刻终止函数,后面的代码通通不执行

(1) return + 可以返回的类型

def func():
	# return 100
	# return 3.45
	# return "我爱你,亲爱的老婶"
	# return [1,2,3]
	# return {"a":1,"b":2}
	# 没有定义任何返回值,默认返回的None
	pass
res = func() # res = 100
print(res)

(2) 遇到return 之后,意味着立刻终止函数,后面的代码不执行

def func():
	print("a")
	print("b")
	return "c"
	print("d")
	print("e")
res = func() 
print(res)		# c
func()			# 'a'\n'b'\n'c'

(3) 模拟一个计算器 + - * /

def calc(sign,num1,num2):
	if sign == "+":
		res = num1 + num2
	elif sign == "-":
		res = num1 - num2
	elif sign == "*":
		res = num1 * num2
	elif sign == "/":
		if num2 == 0 :				# 除数为0时计算会报错
			return "除数不能为0"		# 返回
		res = num1 / num2
	else:							# +-*/以外的计算不算
		return "抱歉,这个值我不会算~"
		
	return res
res = calc("&",3,2)
print(res)		# 抱歉,这个值我不会算~

全局变量 和 局部变量

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

作用域:作用的范围

• 局部变量的作用的范围仅仅限定在函数的内部
  全局变量的作用的范围横跨整个文件

生命周期:

• 内置命名空间 > 全局命名空间 > 局部命名空间
  内置变量 > 全局变量 > 局部变量

(1) 局部变量

def func():
	# 定义一个局部变量
	a = 1
	# 获取局部变量
	print(a)
	# 修改局部变量
	a = 20
	print(a)
	
func()
print(a) error 无法外边获取局部变量的值

(2) 全局变量

# 1.定义全局变量
c = 100
# 2.获取全局变量
print(c)
# 3.修改全局变量
c = 200
print(c)

(3) 在函数内部定义全局变量 global

def func():
	# 标记d这个变量是一个全局变量 
	global d
	d = 400
	print(d)
func()
print(d)

(4) 在函数内部可以修改全局变量

e = 500
def func():
	global e
	e = 600
	print(e)
	
func()
print(e)

global 总结:

如果函数外部有这个全局变量,在函数内部使用global关键字,可以修改全局变量
如果函数外部没有这个全局变量,在函数内部使用global关键字,可以定义全局变量

在函数内部可以直接获取全局变量
但是无法直接修改全局变量,需要通过global

函数名的使用

• python中的函数可以像变量一样,动态创建,销毁,当参数传递,作为返回值,叫做第一类对象,其他语言不能比拟功能有限

1.函数名是个特殊的变量,可以当做变量赋值

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

动态创建函数：

print(func1())	# 我是func1\n111
func = func1	
func()			# 我是func1

动态销毁函数：

del func
func()		# 报错，不存在

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

def func2():
	print("我是func2")
def func3():
	print("我是func3")
def func4():
	print("我是func4")	
	return "func4"
lst = [func2,func3,func4]
for i in lst:		# 遍历依次输出函数
	i()				# 我是func2\n我是func3\n我是func4

3.函数名可以作为函数的参数

def myfunc(f):		# 导入func4
	res = f()		# 执行一次func4()
	print(res)		# 打印func4的返回值:没有就是None

# f <=> func4  <==> res = func4() print(res)
myfunc(func4)		# 导入func4

4.函数名可作为函数的返回值

def myfunc2(f):
	return f
	
f2 = myfunc2(func4) # f2 = func4
print(f2)	# <function func4 at 0x00000208D8CF7DC0>
f2()		# 我是func4

doc 或者help查看文档

函数.doc => 获取函数的帮助文档

模拟一个吃猪大肠的过程

def eat_big_chang(something):
	'''
	功能:模拟一个吃猪大肠的过程
	参数:吃什么?					# 创建为函数进行说明的文档，可以用__doc__获取
	返回值:吃没吃完?
	'''
	print("step1=>先把{}洗一洗".format(something))
	print("step2=>找肠子头放嘴里")
	print("step3=>使劲嘬")
	print("step4=>吃完了,满意的放下肠子")
	return "真好吃~"

res = eat_big_chang("大肠")
print(res)
# 函数.__doc__ => 获取函数的帮助文档
print(eat_big_chang.__doc__)