Python 4.函数参数 返回值与文档查看(基础篇)

  •   本章大纲：(以后文笔格式都会在开头有个大纲)
  •                  -五大参数-
  •                                普通参数
  •                                默认参数
  •                                关键字参数
  •                                收集参数
  •                                         收集参数解包问题
  •                                关键字收集参数
  •                                         关键字收集参数解包问题
  •                  -返回值-
  •                  -文档查看-

 -普通参数-
  • 普通参数又名为位置参数，没有默认值，根据具体使用位置进行传值
  • 普通参数和默认参数的不同
  • 普通参数就是如同名字一般普通,没有默认值
  • 而默认参数则可以规定默认值（也就是规定了默认值的普通参数而已）
  • 但是默认参数要牢记一点：默认参数必须指向不变的对象值
  • 请看下面例子




def  add_end(L=[]):
    L.append('END') # 这里已经添加了一个END
    return L

# 正常调用
print (add_end([1,2,3]))  # [1, 2, 3, 'END']

# 使用默认参数调用时，一开始也是对的，但是再次调用时，结果就不一样了
print (add_end())  # ['END']

print(add_end())  # ['END', 'END']

print(add_end()) # ['END', 'END', 'END']




 


 结果如下：




[1, 2, 3, 'END']
['END']
['END', 'END']
['END', 'END', 'END']




 



 也就是说赋值给默认参数的对象应该为常量

 如果需要修改正确，则需要判断传入时参数是否为空




def  add_end2(L=None):
    if L is None: # 这里的is是身份函数的一种，请翻回上一篇“变量”文章
        L=[]
    L.append('END')
    return  L

print(add_end2())




 




 结果如下：




['END'] # 也跟我们预期的结果一致




 









 -关键字参数-


    

  •  语法
    • 

  •           def func(p1=v1,p2=v2):
    • 

  •                         语句1
    • 

  •                         语句2
    • 

  •                         ……..
    • 

  •  调用函数：
    • 

  •          func(p1=value1,p2=value2)
    • 

  • 

    • 

  •  好处：不容易混淆。一般实参和形参只是按照位置，一一对应即可，容易出错，使用关键字参数，可以不考虑参数位置
    • 

  •  坏处：比较麻烦
    • 




 案例如下:
 案例条件:打印基本信息




def stu(name,age,addr):
    print("我是{0},我今年{1}，我住在{2}".format(name,age,addr))

#定义参数值
n = "zhansan"
a = 18
addr = "广州"
#普通参数传递，只按照位置传递，容易出错
stu(a,n,addr)
#关键字传递，虽然麻烦，但是不容易出错
stu(age=a, name=n, addr=addr)






 结果如下：






我是18,我今年zhansan，我住在广州
我是zhansan,我今年18，我住在广州




 





 -收集参数-


    

  •  把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构(tuple)中
    • 

  •  语法
    • 

  •              def func(*args):
    • 

  •                       func_body
    • 

  •  按照tuple使用方式访问args得到传入的参数
    • 

  •  调用：
    • 

  •             func(p1, p2, p3, …..)
    • 

  •  参数名args不是必须怎么写的，但是推荐使用（约定俗称）
    • 

  •  收集参数参数名前需要带有星号(*)
    • 

  •  收集参数可以和其他参数共存，事实上全部类型参数都可以同时出现在同一个函数里面
    • 




 案例如下
 案例条件:函数模拟学生自我介绍，但是并不是每个学生都有相同的喜好，有的多，有的少


    

  1.  把收集参数看作一个tuple
    2. 

  2.  type为查看内容的类型
    3. 

  3.  type语法： type(args) args=需要查询的内容
    4. 





def stu(*args):
    print("hello,大家好，我先做下自我介绍：")
    print(type(args)) #查看args(收集参数)的类型
    for item in  args:  #因为收集函数是一个tuple，所以使用循环将其全部打印
        print(item)





 调用收集参数




#有同学介绍内容多
stu("zhangsan",18,"广州","篮球","游戏")
 #有同学介绍内容不多
stu("lisi") # 即便只有一个值也使用tuple进行收集
 #收集的内容也能为空
stu()






 


 结果如下：




hello,大家好，我先做下自我介绍：
<class 'tuple'>
zhangsan
18
广州
篮球
游戏
hello,大家好，我先做下自我介绍：
<class 'tuple'>
lisi
hello,大家好，我先做下自我介绍：
<class 'tuple'>




 



 使用关键字参数的格式进行调用收集参数
 例如:调用时候 stu(name="wangwu",我们自己知道name是收集参数里面的那个值，但是系统不知道啊，系统直接当成是一个str类型的同一个变量而已，所以我们就要使用关键字收集参数






-关键字收集参数-


    

  •  把关键字参数按字典(dict)格式存入收集参数
    • 

  •  语法
    • 

  •          def func(**kwargs): 注意是双（*）星号
    • 

  •                  func_body
    • 

  •  调用：
    • 

  •         func(p1=v1, p2=v2, p3=v3……..)
    • 

  •  kwargs也是约定俗成
    • 

  •  调用的时候，把多余的关键字参数放入kwargs
    • 

  •  访问kwargs需要按字典格式访问
    • 




 案例如下
 案例条件:同上自我介绍


    

  1.  调用的时候需要使用关键字参数格式调用
    2. 

  2.  dict里面的items方法返回列表里面可遍历的元素数组
    3. 





def stu(**kwargs):
    print("hello,大家好，我先做下自我介绍：")
    print(type(kwargs)) #查看收集关键字参数的类型
    for k,v in kwargs.items(): #有两个变量进行循环原因是，不仅仅需要打印参数的值，连同关键字参数的参数名也要打印
        print(k+"---"+v) #使用---将其分割开来，好看清楚

stu(name="zhangsan",age="18",addr="广州",lover="游戏",lovers="篮球")
print("分割线"+"*"*20)
stu(name="wangwu")




 


 结果如下：




hello,大家好，我先做下自我介绍：
<class 'dict'>
name---zhangsan
age---18
addr---广州
lover---游戏
lovers---篮球
分割线********************
hello,大家好，我先做下自我介绍：
<class 'dict'>
name---wangwu




 









 关于各类参数调用的顺序问题


    

  1.  之前就说过，收集参数，关键字参数，普通参数，默认参数，关键字收集参数
    2. 

  2.  使用规则：普通参数，默认参数，收集参数，收集关键字参数
    3. 



 混合参数使用案例




def stu(name,age,hobby="没有",*args,**kwargs): #name,age=位置参数，hobby=默认参数，*args=收集参数，**kwargs=收集关键字参数
    print("大家好，我再次介绍一下自己")
    print("我叫{0},今年{1}".format(name,age))
    if hobby == "没有":
        print("对不起，我莫的爱好")
    else:
        print("我的爱好是{0}".format(hobby))
    for i in args:
        print("我住在{0}".format(i))
    for k,v in kwargs.items():
        print("我还有爱好{0}".format(v))





 开始调用




name = "zhansan"
age = 18
 #示范三种不同的调用方法
stu(name,age)
stu(name,age,hobby="游戏")
stu(name,age,"广州","萝岗区",hobby2="游戏",hobby3="篮球")




 




 结果如下：




大家好，我再次介绍一下自己
我叫zhansan,今年18
对不起，我莫的爱好
大家好，我再次介绍一下自己
我叫zhansan,今年18
我的爱好是游戏
大家好，我再次介绍一下自己
我叫zhansan,今年18
我的爱好是广州
我住在萝岗区
我还有爱好游戏
我还有爱好篮球




 





 -收集参数的解包问题-


    

  1. 把收集参数当作一个list或者tuple，拆分成一个一个值，而不是再把它当作一个整体
    2. 

  2. 使用一个星号(*args)进行解包
    3. 




 解包案例如下




def stu(*args):
    print("哇哈哈哈")
     #这里声明一个对象来查看，到底遍历了多少次收集参数
    n = 0
    print(type(args))
    for i in args:
        print(type(i))# 打印args列表里内容的类型
        print(n)
        n += 1
        print(i)
l = ["zhangsan",19,23,"lisi"] #解包=将元祖或列表转化为字符串的过程呈现
stu(*l)
l2 = ("zhangsan",19,23,"lisi")
stu(*l2) 






 结果如下：




哇哈哈哈
<class 'tuple'>
<class 'str'>
0
zhangsan
<class 'int'>
1
19
<class 'int'>
2
23
<class 'str'>
3
lisi
哇哈哈哈
<class 'tuple'>
<class 'str'>
0
zhangsan
<class 'int'>
1
19
<class 'int'>
2
23
<class 'str'>
3
lisi




 


 





 -收集关键字参数的解包问题-


    

  1.  对dict类型进行解包
    2. 

  2.  需要使用两个星号(**args)进行解包
    3. 




 解包案例如下




def stu(**kwargs):
    n = 0;
    print(type(kwargs))
    for k,v in kwargs.items():
        print(type(v))
        print(n)
        n += 1
        print(k+"---"+v)
l1={'name':'zhangsan','age':"12",'names':'lisi','ages':'23'}# 定义字典
stu(**l1) 






 


 




 结果如下：




<class 'dict'>
<class 'str'>
0
name---zhangsan
<class 'str'>
1
age---12
<class 'str'>
2
names---lisi
<class 'str'>
3
ages---23




 


 







 -返回值-


    

  • 
 函数和过程的区别,就是有无返回值

    • 

  •  需要使用return函数返回内容
    • 

  •  如果没有返回，则默认返回None
    • 

  •  推荐写法，无论有无返回值，最后都以return结束（毕竟可以None）
    • 




 返回值案例:有无返回值赋值的区别




def func_1():
    print("有返回值")
    return 1

def func_2():
    print("无返回值")

f1 = func_1()
print(f1)

f2 = func_2()
print(f2) # 在无返回值的情况下，系统默认返回None




 


 结果如下：




有返回值
1
无返回值
None




 









 -函数文档-


    

  •  函数的文档的作用是对当前函数提供使用相关的参考信息
    • 

  •  文档的写法：
    • 

  •  在函数内部开始的第一行使用三引号(”’ ”’，””” “””)字符串定义符
    • 

  •  必须在函数的首行，经过验证前面有注释性说明是可以的，不过最好函数文档出现在首行
    • 

  •  具体格式:
    • 



    

  1.  第一行：函数名称
    2. 

  2.  第二行：函数具体功能
    3. 

  3.  第三行：参数名称以及内容
    4. 

  4.  第四行：是否有返回值
    5. 



    

  •  文档查看：
    • 

  •  是固体不过help函数，形如 help(func)
    • 

  •  使用doc
    • 

  •  help和doc的区别：help的文档查看带有返回值
    • 




 文档写法案例如下
 案例条件:介绍文档内容




def stu(name=10,age=10): # 文档会自动帮我们打印参数信息
    '''
    这是我的文档内容
    :param name:
    :param age:
    :return:
    '''
    print("函数调用成功")# 测试函数是否能成功调用
stu()




 




 使用help文档查看案例




print(help(stu))




 


 结果如下：




函数调用成功
Help on function stu in module __main__:

stu(name=10, age=10)
    这是我的文档内容
    :param name:
    :param age:
    :return:

None




 




 使用doc文档查看案例




print(stu.__doc__)






 


 结果如下：




函数调用成功

    这是我的文档内容
    :param name:
    :param age:
    :return:
    




 


使用doc查询文档并不会出现返回值


文笔不好，仅供参考




要有错误或者有其他更多的见解，欢迎大家加我QQ384435742来交流




想第一时间看更新的文章，请关注，谢谢





			posted on 2018-09-23 16:36 阎冬 阅读(…) 评论(…)  编辑 收藏
		



							

   
版权声明：本文为ggqjlzt原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。



本文链接：https://www.cnblogs.com/ggqjlzt/p/9692913.html