函数一

阿里云2000元红包!本站用户参与享受九折优惠!

函数

一、灵魂三问?

1、什么是函数?

函数就是一种工具,可以重复调用

2、为什么要用函数?

a:为了防止代码冗余

b:为了增强代码的可读性,简介

3、怎么用函数?

关键字def后面空格加函数名加一个小括号后面跟一个重要的冒号

如def login():

OK,那我们定义好了函数要怎么使用函数呢,如果说定义函数是制造工具,那么调用函数就是使用工具。

二、函数的返回值return

1、不写return,默认返回None
def index():
    print('hello world')
print(index())
>>>hello world
None#此时因为没有一个值接受返回值,所以是None
2、只写return,只有结束函数体代码的效果,返回None
def index():
    print('hello world')
    return
print(index())
>>>hello world
None
3、写return None
def index():
    print('hello world')
    return None
print(index())
>>>hello world
None
4、return返回一个值
a = 1
b = 2
def home():
    if a > b:
        return a
    else:
        return b
res = home()
print(res)
>>>2
5、返回多个值
a = 1                     
b = 2                     
c = '3'                   
d = [4, 5]                
e = {'name': 'yafeng'}    
                          
def func(a, b, c, d, e):  
    return a, b, c, d, e  
>>>(1, 2, '3', [4, 5], {'name': 'yafeng'})

三、函数的参数

这里有几个点需要注意:
函数是先定义,后调用,在定义阶段只检测语法,不会执行任何代码
1、形参
形参是在定义函数时,里面小括号中的参数,用来接收参数,就相当于变量名
2、实参
实参是在函数调用阶段后面小括号中的参数,把数据传到函数内部用,相当于定义变量时的变量值
a = 5
b = 2
def index(a):  # 形参:相当于变量名
    if a > b:
        print(a)
    else:
        print(b)
index(a)  # 实参:相当于变量值
>>>5
3、位置参数:
    通过位置进行传参
   关键字参数:
    指定参数进行传参
 注意:位置参数一定不能在关键字参数的前面,连用的时候也不可对同一个形参重复赋值
>>> def register(name,age,sex): #定义位置形参:name,age,sex,三者都必须被传值
...     print('Name:%s Age:%s Sex:%s' %(name,age,sex))
>>> register() #TypeError:缺少3个位置参数
4、关键字参数:
在调用函数时,实参可以是指定值的形式,即key=value的形式,称为关键字参数凡是按
照这种形式定义的实参,可以完全不按照从左到右的顺序定义,但仍能为指定的形参赋值
>>> register(sex='male',name='yafeng',age=18)
Name:yafeng Age:18 Sex:male
5、默认参数:
在定义阶段就已经传入参数,
如果你在实参的时候传入了一个新的参数,就会使用新参数
默认参数在传值的时候,通常应不要将可变类型当做参数传递
def reg(username, password, gender='male'):
    print(f"用户名:{username},密码:{password},性别:{gender}")
reg('tank','dsb')
reg('jason','dsb')
reg('egon','xsb')
reg('xiaohong','dmm','female')
>>>用户名:tank,密码:dsb,性别:male
用户名:jason,密码:dsb,性别:male
用户名:egon,密码:xsb,性别:male
用户名:xiaohong,密码:dmm,性别:female
6、一个小问题(如何不打印别人的爱好)
def reg(hobby, l1=[]):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"爱好:{l1}")
#
reg(hobby='生蚝')
reg('大保健')
reg('女教练')
>>>爱好:['生蚝']
爱好:['生蚝', '大保健']
爱好:['生蚝', '大保健', '女教练']
第一种解决方案:
def reg(hobby, l1=None):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"爱好:{l1}")
#
reg(hobby='生蚝')
reg('大保健')
reg('女教练')
>>>爱好:['生蚝']
爱好:['大保健']
爱好:['女教练']
第二种解决方案:
def reg(hobby, l1):  # 四个形参
    l1.append(hobby)
    print(f"爱好:{l1}")
reg('生蚝', [])
reg('大保健', [])
reg('女教练', [])
>>>爱好:['生蚝']
爱好:['大保健']
爱好:['女教练']

四、可变长参数

  • *args的用法
*args:接收所有溢出的位置参数
    接收的值都被存入一个元组
    官方认证:*args
    只要有*就有可变长参数的效果
    *:打散你传入容器类型
>>> def foo(x,y,z=1,*args): #在最后一个形参名args前加*号
...     print(x)
...     print(y)
...     print(z)
...     print(args)
... 
>>> foo(1,2,3,4,5,6,7)  #实参1、2、3按位置为形参x、y、z赋值,多余的位置实参4、5、6、7都被*接收,以元组的形式保存下来,赋值给args,即args=(4, 5, 6,7)
1
2
3
(4, 5, 6, 7)
  • *kwargs的用法
**kwargs:接收所有溢出的关键字参数
        接收的值都被存入一个字典
    官方认证:**kwargs
def func(a, b, c, d,**kw):
    print(a, b, c, d,kw)
func(1, 2, c=3, d=4, e=5, f=6)
>>>1 2 3 4 {'e': 5, 'f': 6}
如果我们事先生成了一个字典,也可以传值给*kwargs
>>> def foo(x,y,**kwargs):
...     print(x)
...     print(y)
...     print(kwargs)
... 
>>> dic={'a':1,'b':2} 
>>> foo(1,2,**dic) #**dic就相当于关键字参数a=1,b=2,foo(1,2,**dic)等同foo(1,2,a=1,b=2)
1
2
{'a': 1, 'b': 2}
  • 嵌套的用法
def foo(a, b, c, d, e, f):
    print(a, b, c, d, e, f)
def bar(*args, **kwargs):
    foo(*args, **kwargs)
bar(1, 2, 3, d=10, e=20, f=30)
>>>1 2 3 10 20 30

https://www.cnblogs.com/yafeng666/p/11827183.html

Python量化投资网携手4326手游为资深游戏玩家推荐:《三国志奇侠传下载

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论