函数

函数 : 功能(包裹一部分代码,实现某一个功能,达成某一个目的)

“”"
特点:可以反复调用,提高代码的复用性,提升开发效率,便于后期维护
“”"

函数的基本格式

#定义一个函数
def 函数名():
code1
code2
#调用函数
函数名()

函数的定义处

def func():
print(“我是一个函数”)

函数的调用处

func()

函数的名字

“”"
函数的命名
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦

驼峰命名法:
(1) 大驼峰命名法: 每个单词的首字符都大写 mycar => MyCar (面向对象当中,定义类class)
(2) 小驼峰命名法: 除了第一个单词小写之外,剩下每个单词首字符大写 mycar => myCar (函数,变量)
命名一个函数 通常用_拼接的形式,组装不同的单词
mycar => my_car
symmetric_difference
“”"

函数的定义处(99乘法表)

def cfb_99():
for i in range(1,10):
	for j in range(1,i+1):
		print("%d*%d=%2d " % (i,j,i*j) , end="")
	print()

函数的调用

cfb_99()

打印10遍
for i in range(10):
cfb_99()

### 函数的参数 : (参数是配合函数运行时,需要用到的值)

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

形参的种类:
普通(位置)形参,默认形参,普通收集参数,命名关键字参数,关键字收集参数
实参的种类:
普通实参,关键字实参

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

(1) 普通形参

函数的定义处(hang , lie 是普通形参(位置形参))

   	def star(hang,lie):
   	i = 0
     while i<hang:
      	j = 0
	     while j<lie:
	      	print("*",end="")
		j+=1
	print()
	i+=1

函数的调用处

“”“4,9 是实参,是普通实参”""
star(4,9)

(2)默认形参(hang和lie身上带有默认值)

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

“”"
调用时,如果不给实际参数,默认使用自带的值进行调用
调用时,如果给实际参数,那么使用实参来进行调用
“”"
star()

print("<====>")

(3)普通形参 + 默认形参(默认形参必须放到普通形参之后)

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

star(20)

(4) 关键字实参

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)

(5) 普通实参

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 lol_gameteam(top="魏富强",middle="李天照",bottom="尉翼麟",jungle="黄俊",support="神秘男孩"):
print("上单选手:{who}".format(who=top))
print("中单选手:{who}".format(who=middle))
print("下路选手:{who}".format(who=bottom))
print("打野选手:{who}".format(who=jungle))
print("辅助选手:{who}".format(who=support))

函数的调用处 (关键字实参在函数的调用处)

lol_gameteam()
print("<=====>")
lol_gameteam(top="陈宁波",middle="宋青林",bottom="刘思敏",jungle="王振")

### 收集参数

收集参数:
(1) 普通收集参数 :
在参数的前面加上一个*,代表的是普通收集参数.
作用:收集多余的没人要的普通实参,构成一个元组
def func(*args):
pass
args => arguments(参数)

计算任意个数的累加和

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(**kwargs):
strvar = ""
strvar2 = ""
dic = {"monitor":"班长","class_flower":"班花"}
print(kwargs)
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="王振")

### 命名关键字参数

“”"
(1) 在*号后面定义的参数是命名关键字参数
def func(参数1,参数2,星号,参数3)
(2) 在普通收集 和关键字收集参数之间的,是命名关键字参数
def func(*args,参数,**kwargs)

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

“”"

(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")

关于 * 和 ** 的使用方法

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

* 一个星调用处的语法

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)
解释*lst <=> 把列表里面的每一个元素都单独拿出来,
当成参数赋值给func进行调用

** 二个星调用处的语法

func(1,2,c=3,d=4)
或
dic = {"c":3,"d":4}
func(1,2,**dic)
**dic <=> 把字典里面的键值对拿出来,
转化成关键字实参的形式,当成参数赋值给func进行调用;

综合

“”"
定义处的星号用法 和 调用处的*号用法 是一对相反操作
一个是用来打包,一个是用来解包
优点:控制了参数的个数.
“”"

### 参数的顺序

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

收集所有实参

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

参数练习

def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
以上两个函数 打印结果
(一)
f1(1, 2) # a =1 b=2 c=0 args=() kw={}
f1(1, 2, c=3) # a=1 b=2 c=3 args=() kw={}
f1(1, 2, 3, 'a', 'b') # a=1 b=2 c=3 args=(a,b) kw={}
f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2,c=3 args=(a,b) kw={x:99}
 f2(1, 2, d=99, ext=None) # a=1,b=2,c=0 ,d=99,{ext:None}
(二)
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw) # a=1,b=2,c=3,args=(4,) kw={d:99,x:#}
(三)
#myargs = (1, 2, 3)
mykw = {'d': 88, 'x': '#'}
f2(1,2,3,d=88,x=#)
f2(*myargs, **mykw) # a = 1,b=2,c=3,d=88 kw={x:#}
(四)
def f1(a, b, c=0, *args,d,**kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
print(d)

f1(1,2,3, 'a', 'b',d=67, x=99,y=77)
#a =1,b=2,c=3 args=(a,b) kw={x:99,y:77} d=67

### 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
res = func() # res = 100
print(res)

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

def func():
	print("王振")
	print("朱家熠")
	return "尉翼麟"
	print("黄俊")
	print("陈宁波")
res = func() # 尉翼麟
print(res)

注意点: 遇到return 立刻终止函数;

def func():
for i in range(1,10):
	if i == 5:
		return 15
	print(i)
res = func()
print(res)

(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 :
			return "除数不能为0"
			res = num1 / num2
	else:
		return "抱歉,这个值我不会算~"
	
	return res
res = calc("+",10,11)
res = calc("-",10,11)
res = calc("*",2,3)	 res = calc("/",6,2)
res = calc("/",6,0)
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)

在函数内部定义全局变量 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()
#print(res)

动态创建函数

print(func1)
func = func1
func()

动态销毁函数

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()

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

def myfunc(f):
	res = f()
	print(res)
 f <=> func4  <==> res = func4() print(res)
myfunc(func4)

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

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

—doc— 或者help查看文档

模拟一个吃猪大肠的过程

def eat_big_chang(something):
'''
功能:模拟一个吃猪大肠的过程
参数:吃什么?
返回值:吃没吃完?
'''
	print("step1=>先把{}洗一洗".format(something))
	print("step2=>找肠子头放嘴里")
	print("step3=>使劲嘬")
	print("step4=>吃完了,满意的放下肠子")
	return "真好吃~"res = eat_big_chang("大肠")
res=eat_big_chang('大肠'')
print(res)

#函数.–doc– => 获取函数的帮助文档
print(eat_big_chang.____-doc_____)

### locals 和 globals (了解)

locals 获取当前作用域中的所有内容

“”"
locals 如果在函数外,调用locals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
locals 如果在函数内,调用locals(),获取的是调用之前的所有变量,返回字典,局部空间作用域
“”"

例子1

a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4

例子2

a = 1
def func():
	b = 2
	res = locals()
	c = 3
	print(res)
	d = 4
func()

globals 获取全局作用域的所有内容

“”"
globals 如果在函数外,调用globals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
globals 如果在函数内,调用globals(),获取的是调用之前的所有变量,返回字典,全局空间作用域
“”"

例子3

a = 5
b = 6
res = globals()
c = 7
print(res)

例子4

a =10
def func():
	b = 11
	c = 12
	res = globals()
	d= 13
	print(res)
ff = 30
func()
zz = 50

### globals 返回的是系统的字典

1. 正常方式定义变量

zhangsan = “112233”

2. 通过系统的全局字典添加键值对,可以动态创建全局变量

dic = globals()
print(dic)

传递字符串,创建一个变量

k = “wangwen”
dic[k] = “英俊潇洒的人”
print(wangwen)

3.批量创建全局变量,在函数中,通过字符串

def func():
	dic = globals()
	for i in range(1,6):
	dic["p%d" % (i)] = i

func()
print(p1)
print(p2)
print(p3)
print(p4)
print(p5)