标签：值类型 oat %s 没有 方式 架构 dex 初始 结果
#什么函数
函数就是有某个具体功能的工具
函数必须先定义，后面才能调用，并且在任意位置调用
#为什么要用函数
减少某一特定功能的代码冗余
使函数的调用更加方便，提高开发效率
提高程序的扩展性
#定义函数
#使用关键字 def
#函数名与变量名类似，命名规则相同
#该过程不会执行代码，只会检测语法
def func(x,y):
"""
函数的作用
:param x: 对形参x的解释
:param y: 对形参y的解释
:return: 对函数的返回值类型的解释
"""
函数体代码
res = func()
print(res) #None
print(help(func)) #查看函数体内的注释
空函数，可用于构建项目架构
def func():
pass
def func():
...
#调用函数，执行函数体代码
test()
#变量，可以通过变量名找到变量对应的值
#函数，可以通过函数名+括号，找到函数体所对应的代码，并执行
#注意调用函数的时候，到底要不要加括号
#递归深度
def index():
print(‘index‘)
index()
index() #RecursionError:
#自定义函数
l = [1,2,3,4,5]
def my_len():
n = 0
for i in l:
n+=1
print(n)
my_len() #5
a = my_len()
print(a) #None
#内置函数
l = [1,2,3,4,5]
print(len(l)) #5
a = len(l)
print(a) #5
#区别：
1.没有返回值，只能固定的执行打印操作
2.只能固定的统计某一个容器类型的长度
#函数内想要返回给调用者值，必须使用关键字 return
#函数内的print()打印出来的结果，不是函数的返回值，而是函数体代码执行的结果
def func():
print(‘from func‘)
res = func()
print(res)
print(func())
from func
None
from func
None
def func():
return ‘from func‘
res = func()
print(res)
print(func())
from func
from func
def func():
print(func)
def index():
return func
res1 = func()
print(res1)
res = index()
print(res)
<function func at 0x0000028F0BEC1EA0>
None
<function func at 0x0000028F0BEC1EA0>
#不写return
def func():
print(‘哈哈‘)
a = func() #哈哈
print(a) #返回值为None
#只写return
def func():
l = [1,2,3]
while True:
for i in l:
if i == 2:
break
print(i)
break
func()
def func():
l = [1,2,3]
while True:
for i in l:
if i == 2:
return #结束整个函数，关键字return只能用于函数体内部，不执行同级别的其他代码
print(i)
func()
a = func()
print(a) #None，没有返回值
#只写return None，与只写return结果相同
#只写return，返回一个值，这个值可以是python的任意数据类型，还可以返回对象、变量名
def func():
return 123
def func2():
return 12.3
def func3():
return ‘哈哈‘
def func4():
return [1,2,3]
def func5():
return {‘name‘:‘syy‘}
def func6():
return (1,)
def func7():
return {1,2,3}
def func8():
return True
print(func(),func2(),func3(),func4(),func5(),func6(),func7(),func8()) #123 12.3 哈哈 [1, 2, 3] {‘name‘: ‘syy‘} (1,) {1, 2, 3} True
#只写return，返回多个值，return会自动将多个值以元组的形式返回给调用者
def func():
return 1,2,3
res = func()
print(res) #(1, 2, 3)
def func2():
return ‘a‘,‘b‘,‘c‘
res2 = func2()
print(res2) #(‘a‘, ‘b‘, ‘c‘)
def func3():
return [1,],[2,],[3,]
res3 = func3()
print(res3) #([1], [2], [3])
def func4():
return {‘name‘:‘syy‘},{‘name‘:‘syy‘}
res4 = func4()
print(res4) #({‘name‘: ‘syy‘}, {‘name‘: ‘syy‘})
#为什么使用元组作为返回值
函数不希望自己处理的结果被修改
#如何不使用元组作为返回值
使用关键字return的时候指定数据类型
def func():
return 2.2
res = func()
print(res) #2.2
print(type(res)) #<class ‘float‘>
def func():
return ‘[1,],[2.2],["3"]‘
res = func()
print(res) #[1], [2.2], [‘3‘]
print(type(res)) #<class ‘str‘>
def func():
return [[1,],[2.2],[‘3‘,]]
res = func()
print(res) #[[1], [2.2], [‘3‘]]
print(type(res)) #<class ‘list‘>
#python中所有的函数都有返回值，无论写不写return，不写的话默认返回None
#只写return或者return None，这个时候并不是为了考虑返回值，而是为了结束函数的运行
#解压赋值可以与函数连用
def func():
return 1,2,3
a,b,c = func()
print(a,b,c) #1 2 3
a,_,_ = func()
print(a,_) #1 3
a,*_ = func()
print(a,_) #1 [2, 3]
#自定义函数
l = [1,2,3]
def my_len():
n = 0
for i in l:
n+=1
return n
a = my_len()
print(a)
#参数
def my_len(args): #args 为形参，在函数的定义阶段，括号写的‘变量名‘
print(args)
a = my_len(123) #123 为实参，在函数的调用阶段，括号内实际传入的‘值‘
print(a)
#形参与实参的关系;
形参相当于变量名，而实参就相当于变量的值，形参 = 实参
形参与实参的‘绑定关系‘只在函数的‘调用阶段‘有效，函数运行结束，该关系自动解除（只在函数体内部有效，函数外部无任何影响）
#优化自定义函数
l = [1,2,3]
def my_len(args):
n = 0
for i in args:
n+=1
return n
a = my_len(‘hahaha‘)
print(a) #6
#函数定义阶段，按照位置从左向右，依次列出的变量名，叫做函数的位置参数（形参）
#在函数的调用阶段，位置参数少一个不行，多一个也不行（实参）
def my_max(x,y):
if x > y:
return x
else:
return y
res = my_max(2,3) #按位置传参
print(res)
def my_max(x,y):
return x,y
res = my_max(y=1,x=3) #指名道姓的传参（关键字参数）
print(res)
def my_max(x,y):
return x,y
res = my_max(1,y=3) #混用的方式传参（位置参数必须在关键字参数前面，且不能重复赋值）
print(res)
#在函数的定义阶段，形参（变量名）就已经被赋值了
#在函数的调用阶段，可以不给该形参赋值，默认使用该函数在定义阶段就已经绑定的值
#在函数的调用阶段，也可以给该形参赋值，如果赋值就是用新的赋值
#位置参数的格式
def my_max(x,y=100):
if x > y:
return x
else:
return y
res = my_max(10)
print(res)
-------------------------------------------------------------------------
#位置参数的实际使用
def register(username,age,gender):
print(username,age,gender)
register(‘syy‘,18,‘male‘)
register(‘kk‘,28,‘male‘)
register(‘ee‘,58,‘male‘)
register(‘xiaohou‘,17,‘female‘)
代码优化，减少代码冗余
def register(username,age,gender=‘male‘):
print(username,age,gender)
register(‘syy‘,18)
register(‘kk‘,28)
register(‘ee‘,58)
register(‘xx‘,17,‘female‘)
-------------------------------------------------------------------------
def info(username,hobby,l=[]):
l.append(hobby)
print(‘%s的爱好是: %s‘%(username,l))
info(‘syy‘,‘run‘)
info(‘ee‘,‘女教练‘)
info(‘hh‘,‘逗比‘)
代码优化1
def info(username,hobby,l=[]):
l.append(hobby)
print(‘%s的爱好是: %s‘%(username,l))
info(‘syy‘,‘run‘,[])
info(‘ee‘,‘女教练‘,[])
info(‘hh‘,‘逗比‘,[])
代码优化2
def info(username,hobby,l):
if l == None:
l = []
l.append(hobby)
print(‘%s的爱好是: %s‘%(username,l))
info(‘syy‘,‘run‘,[])
info(‘ee‘,‘女教练‘,[])
info(‘hh‘,‘逗比‘,[])
-------------------------------------------------------------------------
#函数在定义阶段，内部所有使用的变量都已经初始化完毕了，不会因为调用的位置的变化，而影响到内部的值
#函数无论在什么位置被调用，都会到函数定义阶段去执行代码，形参中用到的值都是从函数定义阶段向上找
m = 999
def my_max(x,y=m):
if x > y:
print(x)
else:
print(y)
m = 888
my_max(10) #999
*
#在形参中，可以使用*来接收多余的位置参数
#形参中的*，会将多余的实参，统一用元组的形式处理，传递给*后面的形参
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5) #1 2 (3, 4, 5)
def func(x,y,*z):
print(x,y,z)
func(1,2,z=3) #TypeError:
#在实参中，*会将列表打散成实参中的位置参数
#*相当于是一个 for循环
def func(x,y,z):
print(x,y,z)
func(1,2,3) #1 2 3
def func(x,y,z):
print(x,y,z)
func(*[1,2,3]) #1 2 3
def func(x,y,z):
print(x,y,z)
func(*{‘name‘:‘syy‘,‘age‘:18,‘hobby‘:‘run‘}) #name age hobby
**
#在形参中，**会接收多有多余的关键字参数，并将关键字参数转换成字典的形式
#变量名就是字典中的key，变量值就是字典中的value,再将字典复制给**后面的变量名
def func(x,y,**z):
print(x,y,z)
func(1,2,z=1,a=2,b=3) #1 2 {‘z‘: 1, ‘a‘: 2, ‘b‘: 3}
#在实参中，**会将字典拆分成 key=value的形式
def func(x,y,z):
print(x,y,z)
func(1,2,3)
func(x=1,y=2,z=3)
func(**{‘x‘:1,‘y‘:2,‘z‘:3})
#*和**的总结
1.*在形参中，能接收多余的‘位置参数‘，组织成一个‘元组‘，赋值给*后面的变量名
2.**在形参中，能接收多余的‘关键字参数‘，阻止成一个‘字典‘.赋值给**后面的变量名
3.*在实参中，能将‘字符串、 列表、元组、集合‘打散成实参中的位置参数（*相当于for循环）
4.**在实参中，能将‘字典‘打散成 ‘key=value‘ 的形式
def func(*args,**kwargs):
print(args,kwargs)
func(1,2,3,x=1,y=2,z=3) #(1, 2, 3) {‘x‘: 1, ‘y‘: 2, ‘z‘: 3}
#在函数定义阶段，写在可变长参数*与**之间的形参
#只能使用关键字参数给命名关键字参数传值
#下面的z=3,m 不是默认参数、位置参数，而是命名关键字参数
def func(x,y,*args,z=3,m,**kwargs):
print(x,y) #1 2
print(args) #(1, 2, 3, 4, 5)
print(z,m) #333 444
print(kwargs) #{‘k‘: 111, ‘v‘: 222}
func(1,2,1,2,3,4,5,z=333,m=444,k=111,v=222)
标签：值类型 oat %s 没有 方式 架构 dex 初始 结果
原文地址：https://www.cnblogs.com/syy1757528181/p/14059468.html
