python函数的参数属于全局变量_Python_09_函数_参数_返回值_函数名_局部与全局变量...

文章目录

函数

满足某一个方法 满足某一个功能

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

可以反复调用,提高代码的复用性,提高开发效率,便于维护管理

函数的基本格式

定义一个函数

def 函数名():

code1

code2

123

调用函数

函数名()

def func():

print('朋友问我,是的分手')

func()

1234

函数的命名

字母数字下划线 首字符不能为数字

严格区分大小写 且不能使用关键字

函数命名有意义 且不能使用中文哦

驼峰命名法:

大驼峰命名法 : 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()

12345678910

函数的参数

参数:形参 + 实参

形参: 形式参数 在函数的定义处

实参: 实际参数 在函数的调用处

形参: 普通形参(位置形参) , 默认形参, 普通收集形参 , 命名关键字形参, 关键字收集形参

实参: 普通实参,关键字实参

形参 和 实参 要一一对应

普通形参(位置参数)

# 函数的定义处 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)

12345678

默认参数

如果不写任何的实参,那么使用默认形参的值

如果写了自定义的实参,那么使用实际参数.

# 函数的定义处 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)

1234567891011

普通形参 + 默认形参

普通形参 必须 放在默认形参的前面

def little_star(row,column=10):

for i in range(row):

for j in range(column):

print('*',end='')

print()

little_star(6,12)

12345678

关键字实参

如果使用了关键字实参进行调用,顺序随意

如果定义时是普通形参,但调用时使用了关键字实参调用,那么这个参数的后面所有参数都必须使用关键字实参

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)

12345678910

默认形参 与 关键字实参的区别

# 函数的定义处 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='卢西奥')

123456789101112131415161718192021

收集参数 (可变参数)

普通收集参数

关键字收集参数

普通收集参数

语法:

def func(*参数):

pass

123

参数前面加上一个* 的就是普通收集参数;

普通收集参数专门用于收集多余的,没人要的普通实参,形成一个元组

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)

123456789101112131415

关键字收集参数

语法

def func(**参数):

pass

123

参数前面加上的就是关键字收集参数**

关键字收集参数:用于收集多余的,没人要的关键字实参,形成一个字典

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="黄将用")

12345678910111213141516171819202122232425262728293031

命名关键字

语法:

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

pass

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

pass

12345

在函数的定义处,* 号后面的参数就是命名关键字参数

在函数的定义处,在普通收集参数和关键字收集参数之间的是命名关键字参数

命名关键字必须使用关键字实参的形式进行调用

# 形式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)

1234567891011121314151617181920

*和**的魔术用法:打包和解包

*和,在函数的定义处**,负责打包(把实参都收集过来,放在元组或字典中)

*和,在函数的调用处**,负责解包(把容器类型的数据,一个一个拿出来,进行传递)

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)

12345678910111213141516

函数参数的默认顺序

必须按照如下的参数顺序进行定义:

普通形参(位置形参) -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数

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

1234567891011121314151617181920212223242526

函数的返回值 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)

123456789

如果不写return ,默认返回None

def func():

a =1

res = func()

print(res)

1234

执行完return 之后,函数立刻终止,后面的代码不执行

def func():

print("执行到1")

print("执行到2")

return 1

print("执行到3")

print("执行到4")

return 2

res = func()

print(res)

12345678910

例：计算器

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)

123456789101112131415161718192021

函数名的使用

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

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

def func():

print(1)

# 变量的赋值操作

func2 = func

func2() # func()

12345

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

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() # 函数的调用

1234567891011121314

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

def func(a): # a = func2

res = a()

print(res)

def func2():

return 123

func(func2)

12345678

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

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)

1234567891011

__doc__或者help查看文档

help

help(print)

1

doc 魔术属性

res = print.__doc__

print(res)

12

自定义函数文档

def kao_qiezi(qimin):

'''

功能:告诉你如何做烤茄子

参数:是一个器皿

返回值:返回烧烤的状态

'''

print("从中间抛开,扔到烧烤架子上面")

print("扔胡椒面,扔孜然,扔蒜蓉,扔香菜")

print("用一个%s来盛放" % (qimin))

return "这个茄子做好了"

kao_qiezi("盆")

help(kao_qiezi)

123456789101112

局部变量 与 全局变量

局部变量:在函数内部声明的变量就是局部变量.

全局变量:在函数外部声明的变量或用global关键字在函数内部声明的变量

作用域:作用的范围

局部变量:作用范围在函数的内部

全局变量:作用范围横跨整个文件

局部变量的获取和修改

def func():

a = 1

# 获取局部变量

print(a)

# 修改局部变量

a = 2

print(a)

func()

12345678

全局变量的获取和修改

c = 15

# 获取

print(c)

# 修改

c = 78

print(c)

123456

global

在函数内部通过global 修改全局变量

c = 12

def func():

# 如果不加global c 只能获取 不能修改

# 加了global c 告诉系统在函数内部允许修改全局变量c

global c

print(c)

c = 90

func()

print(c)

123456789

在函数内部通过global 定义全局变量

def func():

global ff

ff = 980

func()

print(ff)

1234567

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

123456789

nonlocal 修改的是局部变量,不是全局变量.

a = 16

def outer():

a = 10

def inner():

# a = 11

def smaller():

nonlocal a

a += 3

print(a)

smaller()

inner()

outer()

123456789101112

不使用nonlocal 是否可以修改局部变量? 可以

def outer():

# a = 3

lst = [1,2,3,4,5]

def smaller():

lst[2] += 5

smaller()

print(lst)

outer()

123456789

注意点：

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