文章目录
函数
满足某一个方法 满足某一个功能
- 功能 (包裹一部分代码 实现某一个功能 达成某一个目的)
- 可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
函数的基本格式
- 定义一个函数
def 函数名():
code1
code2
- 调用函数
函数名()
def func():
print('朋友问我,是的分手')
func()
函数的命名
字母数字下划线 首字符不能为数字
严格区分大小写 且不能使用关键字
函数命名有意义 且不能使用中文哦
驼峰命名法:
- 大驼峰命名法 : myfunc => MyFunc 应用在面向对象程序当中的类名
- 小驼峰命名法 ：myfunc => myFunc 用在函数上(不做强制要求)
myfunc => my_func (推荐)
# 函数的定义处 def
def multiplication_table():
for i in range(1,10):
for j in range(1,i+1):
print('%d*%d=%2d ' % (i,j,i*j),end='')
print()
# 函数的调用处
multiplication_table()
multiplication_table()
函数的参数
参数:形参 + 实参
形参: 形式参数 在函数的定义处
实参: 实际参数 在函数的调用处
形参: 普通形参(位置形参) , 默认形参, 普通收集形参 , 命名关键字形参, 关键字收集形参
实参: 普通实参,关键字实参
形参 和 实参 要一一对应
普通形参（位置参数）
# 函数的定义处 row column叫做 普通形参 或者 叫做位置形参
def little_star(row,column):
for i in range(row):
for j in range(column):
print('*',end='')
print()
# 函数的调用处 10,10 叫做普通实参
little_star(10,10)
默认参数
如果不写任何的实参,那么使用默认形参的值
如果写了自定义的实参,那么使用实际参数.
# 函数的定义处 row=10,column=10 默认形参
def little_star(row=10,column=10):
for i in range(row):
for j in range(column):
print('*',end='')
print()
# 函数的调用处 3 4 普通实参
little_star()
little_star(3)
little_star(4,6)
普通形参 + 默认形参
普通形参 必须 放在默认形参的前面
def little_star(row,column=10):
for i in range(row):
for j in range(column):
print('*',end='')
print()
little_star(6,12)
关键字实参
- 如果使用了关键字实参进行调用,顺序随意
- 如果定义时是普通形参,但调用时使用了关键字实参调用,那么这个参数的后面所有参数都必须使用关键字实参
def little_star(row,a,b,c,column=10):
print(row,a,b,c,column)
for i in range(row):
for j in range(column):
print('*',end='')
print()
little_star(2,3,4,5,6)
little_star(7,a=2,b=4,c=7,column=13)
默认形参 与 关键字实参的区别
# 函数的定义处 tank_1,tank_2,damage_1 ... 默认形参
def overwatch_team(
tank_1='查莉雅',
tank_2='莱因哈特',
damage_1='源氏',
damage_2='猎空',
support_1='天使',
support_2='禅雅塔'):
print('1号重装英雄是:{t1}'.format(t1=tank_1))
print('2号重装英雄是:{t2}'.format(t2=tank_2))
print('1号输出英雄是:{c1}'.format(c1=damage_1))
print('2号输出英雄是:{c2}'.format(c2=damage_2))
print('1号辅助英雄是:{s1}'.format(s1=support_1))
print('2号辅助英雄是:{s2}'.format(s2=support_2))
# 函数的调用处
# 关键字实参
# overwatch_team() tank_1,damage_1,support_2 关键字实参
overwatch_team()
overwatch_team(tank_1='Winston', damage_1='士兵76', support_2='卢西奥')
收集参数 (可变参数)
- 普通收集参数
- 关键字收集参数
普通收集参数
语法:
def func(*参数):
pass
参数前面加上一个* 的就是普通收集参数;
普通收集参数专门用于收集多余的,没人要的普通实参,形成一个元组
def func(a,b,c,*args):
print(a,b,c) # 1,2,3
print(args) # (4,5,6)
func(1,2,3,4,5,6)
# args => arguments 参数
# 计算任意长度的累加和
# 函数的定义处
def mysum(*args):
total = 0
print(args)
for i in args:
total += i
print(total)
mysum(1,5,7,1000)
关键字收集参数
语法
def func(**参数):
pass
参数前面加上**的就是关键字收集参数
关键字收集参数:用于收集多余的,没人要的关键字实参,形成一个字典
def func(a,b,c,**kwargs):
pass
# kwargs => keyword关键字 arguments多个参数
def func(a,b,c,**kwargs):
print(a,b,c)
print(kwargs)
func(1,2,3,f=11,d=13,zz=99)
# 打印任意长度的字符
# 班长:黄文
# 班花:陈广耀
def func(**kwargs):
dictvar = {"monitor":"班长","class_flower":"班花"}
strvar1 = ''
strvar2 = ''
print(kwargs)
for a,b in kwargs.items():
if a in dictvar:
strvar1 += dictvar[a] + ":" + b + '\n'
else:
strvar2 += "吃瓜群众:" + b+'\n'
print(strvar1)
print(strvar2)
func(monitor="黄文",class_flower="陈广耀",people1="黄熊大",people2="黄将用")
命名关键字
语法:
def func(参数1,参数2,*,参数3,参数4):
pass
def func(*args,命名关键字参数,**kwargs):
pass
- 在函数的定义处,* 号后面的参数就是命名关键字参数
- 在函数的定义处,在普通收集参数和关键字收集参数之间的是命名关键字参数
命名关键字必须使用关键字实参的形式进行调用
# 形式1
def func(a,b,*,c):
print(a,b,c)
func(1,2,c=4)
# 形式2
'''
如果命名关键字指定了默认值,那么在调用时,
可以不指定实参.默认使用自己的值
'''
def func(a,b,*,c=5):
print(a,b,c)
func(1,2,c=6)
# 形式3
def func(*arg,d,**kwargs):
print(arg) # 1 2 23
print(kwargs) # {c:1,f:2}
print(d) # d = 3
func(1,2,23,c=1,f=2,d=3)
*和**的魔术用法:打包和解包
- *和**,在函数的定义处,负责打包(把实参都收集过来,放在元组或字典中)
- *和**,在函数的调用处,负责解包(把容器类型的数据,一个一个拿出来,进行传递)
def func(a,b,c):
print(a,b,c)
listvar = [1,2,3]
# *一般修饰列表更多一些 (负责把列表里面的元素一个一个拿出来的进行函数调用)
func(*listvar) # <==> func(1,2,3)
def func(a,b,c,*,d,e,f):
print(a,b,c)
print(d,e,f)
listvar = [1,2,3]
dic = {"d":4,"e":5,"f":6} # func(d=4,e=5,f=6)
# **一般修饰字典,(负责把字典里面的键值对变成d=4,e=5的形式,进行函数调用)
func(1,2,3,**dic) # <==> d=4 , e = 5 , f = 6
# * 和 ** 的解包操作
func(*listvar,**dic)
函数参数的默认顺序
必须按照如下的参数顺序进行定义:
普通形参(位置形参) -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
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,kw={'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(*myargs, **mykw) #a=1,b=2,c=3,d=88,kw={"x":"#"}
def f3(a, b, c=0, *args,d,**kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
print(d)
# 调用处
f3(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 后面可以跟上六大标准数据类型 , 除此之外,可以跟上 类对象,函数,如果不写return ,默认返回None
- return 如果执行了return ,意味着 return后面得所有代码,统统不执行,函数终止了.
- return 后面的数据类型
def func():
# return 1
# return 3.14
# return True
# return 4j
# return [1,2,3,4]
return {"a":1,"b":2}
res = func() # res = {"a":1,"b":2}
print(res)
- 如果不写return ,默认返回None
def func():
a =1
res = func()
print(res)
- 执行完return 之后,函数立刻终止,后面的代码不执行
def func():
print("执行到1")
print("执行到2")
return 1
print("执行到3")
print("执行到4")
return 2
res = func()
print(res)
例：计算器
print("<===>")
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("^",5,0)
print(res)
# print打印的值和返回值是两个不相干的概念 return + 值 自定义的
# res = print(123)
# print(res)
函数名的使用
python中的函数可以像变量一样,动态创建,销毁,当参数传递,作为值返回,叫第一类对象.其他语言功能有限
- 函数名是个特殊的变量,可以当做变量赋值
def func():
print(1)
# 变量的赋值操作
func2 = func
func2() # func()
- 函数名可以作为容器类型数据的元素
def func1():
print(1)
def func2():
print(2)
def func3():
print(3)
def func4():
print(4)
lst = [func1,func2,func3,func4]
for i in lst:
# print(i)
i() # 函数的调用
- 函数名可以作为函数的参数
def func(a): # a = func2
res = a()
print(res)
def func2():
return 123
func(func2)
- 函数名可作为函数的返回值
def func(a): # a = func2 return a <==> return func2
return a
def func2():
return 456
# 函数的调用处
res = func(func2) # res = func2
print(res)
total = res() # res() <==> func2()
print(total)
__doc__或者help查看文档
- help
help(print)
- __doc__ 魔术属性
res = print.__doc__
print(res)
- 自定义函数文档
def kao_qiezi(qimin):
'''
功能:告诉你如何做烤茄子
参数:是一个器皿
返回值:返回烧烤的状态
'''
print("从中间抛开,扔到烧烤架子上面")
print("扔胡椒面,扔孜然,扔蒜蓉,扔香菜")
print("用一个%s来盛放" % (qimin))
return "这个茄子做好了"
kao_qiezi("盆")
help(kao_qiezi)
局部变量 与 全局变量
局部变量:在函数内部声明的变量就是局部变量.
全局变量:在函数外部声明的变量或用global关键字在函数内部声明的变量
作用域:作用的范围
局部变量:作用范围在函数的内部
全局变量:作用范围横跨整个文件
- 局部变量的获取和修改
def func():
a = 1
# 获取局部变量
print(a)
# 修改局部变量
a = 2
print(a)
func()
- 全局变量的获取和修改
c = 15
# 获取
print(c)
# 修改
c = 78
print(c)
global
- 在函数内部通过global 修改全局变量
c = 12
def func():
# 如果不加global c 只能获取 不能修改
# 加了global c 告诉系统在函数内部允许修改全局变量c
global c
print(c)
c = 90
func()
print(c)
- 在函数内部通过global 定义全局变量
def func():
global ff
ff = 980
func()
print(ff)
python特有:
如果外部存在该全局变量,那么利用global关键字,可以允许在函数内部修改全局变量
如果外部不存在该全局变量,那么利用global关键字,可以允许在函数内部定义全局变量
在使用global 关键字的时候,一般写在函数内部的第一行.
nonlocal
专门用于修改局部变量
(1)它自动寻找上一层空间的局部变量用来修改
(2)如果上一级也没有,在不停的向上寻找
(3)如果再也找不到了,直接报错
- nonlocal 符合LEGB原则
def outer():
a = 15
def inner():
nonlocal a
a = 17
print(a)
inner()
print(a)
outer()
- nonlocal 修改的是局部变量,不是全局变量.
a = 16
def outer():
a = 10
def inner():
# a = 11
def smaller():
nonlocal a
a += 3
print(a)
smaller()
inner()
outer()
- 不使用nonlocal 是否可以修改局部变量? 可以
def outer():
# a = 3
lst = [1,2,3,4,5]
def smaller():
lst[2] += 5
smaller()
print(lst)
outer()
注意点：
# a = 20
def outer():
a = 81
def inner():
global a
a = 16
def smaller():
# nonlocal a
# print(a) # 获取a
# global a
# a+=3
# 上一级找到的是一个全局变量,nonlocal无法修改
nonlocal a
print(a)
smaller()
inner()
outer()
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
