函数

• 代码的一种组织形式
• 一个函数完成一项特定的功能
• 函数的定义
  • 使用def 关键字来定义函数
  • 使用函数俗称调用
• 函数的调用
  • 直接使用函数名后面加上括号(),根据函数是否带有参数,如果有参数则在调用时需要传递参数

# 定义一个函数
# 只是定义的话不会执行

def func():
    print("我是一个函数")
    print("我要完成一个功能")
    print("我已经结束了")
    

#函数的调用
func()

我是一个函数
我要完成一个功能
我已经结束了

函数的参数和返回值

• 参数:负责给函数传递一些必要的数据或信息
• 返回值:函数的返回结果

参数的使用

• 在调用函数时向函数传递的一个值
• 形参: 在函数定义的时候没有具体的值,只是一个占位符
• 实参:在调用函数的时候输入实际的值
• 参考资料:(http://www.cnblogs.com/bingabcd/p/6671368.html)
  • 参数类型

    • 普通参数

      • 定义的时候直接定义变量名

      • 调用的时候直接把变量或直接放入指定为准

          def 函数名(参数1,参数2,.....)
              语句块
        
         # 调用
          函数名(value1,value2,.......)
        

    • 默认参数

      • 形参代用默认值,如果调用的时候没有对形参进行赋值,那么就使用默认值

          def func_name(p1=v1,p2=v2,......)
              语句块
          
          #调用
          func_name()
          #调用2
          func_name(100,200)
        

    • 关键字参数

      • 语法

           def func_test(p1=value,p2=value2,.....):
               funcBody
               
           #调用
           func_test(p1="zhangsan",p2="18",.......)
        

      • 在参数多的情况下,不容易混淆

      • 在使用关键字参数的时候,不用考虑参数的位置

    • 收集参数

      • 把没有位置,不能够定义是的参数位置相对应的参数,放入一个特定的数据结构中

      • 语法
        def func_test(*ages):
        funcBody

          #调用
          func(val1,val2,val3.....)
        

      • 参数名没有强制要求,但是推荐使用ages

      • 参数名ages 前面必须加入*号

      • 收集参数和其他参数可以共存

      • 收集该参数之关键字参数

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

        • 语法

            def func( **kwages):
                funcBody
             
            #调用
            func(p1=v1,p2=v2,.......)
          

        • kwage是通常的约定

        • 调用时,吧多余的关键字参数放入kwages

        • 访问kwages时,需按照字典格式进行访问

# 参数的定义和使用
def hello(person):
    print("{0}!你肿么了?".format(person))
    print("Sir,你不理我我就走了哦.....")
    # 向调用者返回一个值
    return "你走开!"

p = "明月"
# 获取返回值
ret = hello(p)
print(ret)

明月!你肿么了?
Sir,你不理我我就走了哦.....
你走开!

# 打印一行乘法表
def multiplication(row):
    for col in range(1,row+1):
        ji = col * row
        print("{0}*{1}={2}".format(col,row,ji),end="  ")
    print("")
    
# 打印99乘法表
for row in range(1,10):
    multiplication(row)

1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12   4*4=16   
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25   
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36   
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49   
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64   
1*9=9   2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81   

#默认参数案例
def reg(name,age,gender="male"):
    if(gender=="male"):
        print("{0} is {1},and he is a good student".format(name,age))
    else:
        print("{0} is {1},and she is a good student".format(name,age))
        
reg("zhagnsan",18)

reg("xiaojing",17,"female")

zhagnsan is 18,and he is a good student
xiaojing is 17,and she is a good student

#关键字参数案例
def func_student(name="NO Name", age=0, addr="中国"):
    print("我是一个学生!")
    print("我叫{0},我今年{1}岁了,我住在{2}".format(name,age,addr))

func_student(age=22, name="张三", addr="成都")

我是一个学生!
我叫张三,我今年22岁了,我住在成都

收集参数混合调用的顺序问题

• 收集参数,关键字参数,普通参数可以混合使用
• 使用规则就是,普通参数和关键字参数优先
• 定义的时候一般找普通参数,关键参数,收集参数tuple,收集参数Dictionary

# 收集参数案例
def func_student(*ages):
    print("Hello 大家好!")
    # type函数 检测数据的类型
    #print(type(ages))
    for item in ages:
        print(item)
        
func_student("张三", 18, "北京市大通区", "wangxiaoj", "single")

func_student("李四", 22, "我喜欢电影")

# 说明收集参数可以为空
func_student()

Hello 大家好!
张三
18
北京市大通区
wangxiaoj
single
Hello 大家好!
李四
22
我喜欢电影
Hello 大家好!

#收集参数之关键字参数案例
def stu( **kwages):
    print("Hello! 大家好,我先自我介绍一下:")
    #在循环字典的时候,将字典转换成键值队的方式 即 key:value的形式
    for k,v in kwages.items():
        print(k, "...", v)

stu(name="wangxiaoj", age=19, addr="北京市大通州区", love="xiaojinjin", work="Teacher")

# 将*号重复20遍
print("*" * 20)

stu(name="周伯通")
#同样 参数可以为空
stu()

Hello! 大家好,我先自我介绍一下:
name ... wangxiaoj
age ... 19
addr ... 北京市大通州区
love ... xiaojinjin
work ... Teacher
********************
Hello! 大家好,我先自我介绍一下:
name ... 周伯通
Hello! 大家好,我先自我介绍一下:

#收集参数混合使用的案例
#使用默认参数时，注意默认参数的位置要在args之后kwargs之前
def stu(name, age, *ages, hobby="没有", **kwages):
    print("Hello 大家好!")
    print("我叫{0}, 我今年{1}岁了!".format(name,age))
    if hobby=="没有":
        print("sorry!我没有爱好!!")
    else:
        print("我的爱好是{0}".format(hobby))
        
    print("我不喜欢")
    for item in ages:
        print(item,end=" ")
    
    print("我的主修课是:")
    for k,v in kwages.items():
        print(k,"---",v)

        
stu("李晓明", 20)

print("*" * 30)

stu("王晓静", 22, "逛街", "购物", "上网", "游戏", hobby="音乐", course="音乐课", score=98)

Hello 大家好!
我叫李晓明, 我今年20岁了!
sorry!我没有爱好!!
我不喜欢
我的主修课是:
******************************
Hello 大家好!
我叫王晓静, 我今年22岁了!
我的爱好是音乐
我不喜欢
逛街 购物 上网 游戏 我的主修课是:
course --- 音乐课
score --- 98

收集参数的解包的问题

• 把参数放入list中或者字典中,直接吧list/dictionary中的值放入收集参数中
• 解包符号
  • 对与list\tuple的解包在调用函数的时候,在参数前面加上*即可
  • 对dictionary的解包在参数前面加上**即可

# 解包的案例
def stu(*ages):
    print("哈" * 10)
    for index in ages:
        print(index)
        
l = list()
l.append("wangxiaojing")
l.append(18)
l.append("apple")
stu(l)
print("***" * 10)
#解包list的调用方法
stu(*l)

哈哈哈哈哈哈哈哈哈哈
['wangxiaojing', 18, 'apple']
******************************
哈哈哈哈哈哈哈哈哈哈
wangxiaojing
18
apple

返回值

• 使用return向函数的调用者返回函数需要向调用者返回的数据
• 如果没有return,默认返回None
• 函数只要执行到了return,无条件返回数据,如果函数在return后面还有代码的话,则不在执行
• 推荐写法,无论有无返回值,都应该加上return,以表示函数结束!

# 返回值案例
def func1():
    print("我有返回值!")
    return 1

def func2():
    print("我没有返回值")
    
f1 = func1()
print(f1)

print("")

f2 = func2()
print(f2)

我有返回值!
1

我没有返回值
None

函数文档

• 函数的文档的作用是对当前函数提供使用的相关功能的参考信息
• 文档的写法
  • 在函数内部开始的第一行使用三个单引号定义
  • 一般具有特定的格式
• 文档查看
  • 使用help函数,如:help(test)
  • 使用doc,如:test.doc

#函数文档案例
def stu(name, age, *ages):
    '''这是stu文档'''
    print("这是一个函数文档")
    
stu.__doc__

'这是stu文档'

# 查找函数的帮助文档
#1.使用help文档
help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.