Python自学-简单函数

# 函数
# - 代码的一种组织形式
# - 一个函数一般完成一项特定的功能
# - 函数使用
# ---- 函数需要先定义
# ---- 使用函数，俗称调用

 # 定义一个函数，只是定义不会执行
 # 1.def 关键字，后跟一个空格
 # 2.函数名，自定义时，需遵循命名规则，大驼峰命名只给类用
 # 3.后面扩后和冒号不能省，括号内可以有参数
 # 4.函数内部所有代码缩进

 def func():
     print("I'm a function.")
     print("I will do something.")
     print("I done.")
 
 # 函数的调用，直接函数名后面跟括号
 func()

# 函数的参数和返回值
# - 参数：负责给函数传递一些必要的数据或者信息
# ---- 形参（形式参数）：在函数定义的时候用到的参数没有具体值，只是一个占位符
# ---- 实参（实际参数）：在调用函数的时候输入的值
# - 返回值：函数的执行结果
# ---- 使用 return 关键字
# ---- 如果没有 return ,默认返回一个 None
# ---- 函数一旦执行 return 语句，则无条件返回，即结束函数的执行
# ---- 推荐写法，无论是否有返回值，最后都要以 return 结束

    # 参数的定义和使用
    # 参数 person 只是一个符号，代表的是调用的时候的某一个数据
    # 调用的时候，会用 p 的值代替函数中所有的 person
    def hello(person):
        print("{0},how are you?".format(person))
        print("Sir,if you don't answer me,I will gone.")
        return "I have said hi to {0},{0} don't look me.".format(person)
    p = "明月"
    hello(p)

    # return 案例
    def hello(person):
        print("{0},how are you?".format(person))
        return "I have already gone."
        print("Sir,if you don't answer me,I will gone.")
        return "I have said hi to {0},{0} don't look me.".format(person)
    p = "JingTen"
    rst = hello(p)
    print(rst)

# 函数文档
# - 函数文档的作用是对当前函数提供使用相关的参考信息
# - 文档的写法：
# ---- 在函数内部开始的第一行使用三字符定义符
# ---- 一般具有特定的格式
# - 文档查看
# ---- 使用 help 函数，形如 help(func1)
# ---- 使用 __doc__

    def stu(name,age,*args):
        '''
        文档
        第一行
        第二行
        第三行
        '''
        print("This is function of stu")
    # 查找函数帮助文档
    # 1.使用 help 函数
    help(print)
    help(stu)
    stu.__doc__

    # 九九乘法表
    for row in range(1,10):
        for col in range(1,row+1):
            # print 函数默认任务打印完成后换行
            print(row*col,end = " ")
        print("--------")

    # 定义一个函数，打印一行九九乘法表
    def printLine(row):
        for col in range(1,row+1):
            # print 函数默认任务打印完成后换行
            print(row*col,end=" ")
        print("")
        
    for row in range(1,10):
        printLine(row)

# 参数详解
# - 【参考资料】(https://cnblogs.com/bingabcd/p/6671368.html)

# 参数四类
# ---- 普通参数
# ---- 默认参数
# ---- 关键字参数
# ---- 收集参数

# - 普通参数
# ---- 定义的时候直接定义变量名
# ---- 调用的时候直接把变量或者值放入指定位置

#      def 函数名(参数1，参数2，...)
#          函数体
#      # 调用
#      函数名(value1,value2,...)
#      # 调用的时候，具体值参考的是位置，按位置赋值

# - 默认参数
# ---- 形参带有默认值
# ---- 调用的时候，如果没有相对形参赋值，则使用默认值

#      def func_name(p1=v1,p2=v2,...)
#          func_block
#      # 调用1
#      func_name()
#      # 调用2
#      value1 = 100
#      value2 = 200
#      func_name(value1,value2)

# - 关键字参数
# ---- 语法
#      def func(p1=v1,p2=v2,...):
#          func_body
#      # 调用参数
#      func(p1=value1,p2=value2,...)
# ---- 书写较麻烦，但也有好处：
#      - 不容易混淆，一般实参和形参只是按照位置一一对应即可
#      - 使用关键字参数，可以不考虑参数位置

# - 收集参数
# ---- 把没有位置，不能和定义的参数位置相对应的参数，放入一个特定的数据结构中
# ---- 语法
#      def func(*args):
#          func_body
#      # 调用
#      func(p1,p2,p3,...)
# ---- 参数名 args 可以随意更改，但推荐直接使用约定俗称的 args
# ---- 参数名 args 前面需要加星号 *
# ---- 收集参数可以和其他参数共存，也可以为空

    # 默认参数实例
    # 报名函数，需要知道学生性别
    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("JingTen",26)
    reg("xiaojing",18,"female")

    # 关键字参数案例
    def stu(name,age,addr):
        print("I'm a good student.")
        print("I'm {0},I have {1} years old,I live in {2}.".format(name,age,addr))
    
    n = "JingTen"
    a = 26
    addr = "GuangZhou"
    
    stu(n,a,addr)    # 普通参数，按位置传递，需一一对应，容易出错
    print("\n")
    stu(age=a,name=n,addr=addr)    # 关键字参数，可不考虑位置

    # 收集参数代码
    # 函数模拟一个学生进行自我介绍，但具体内容不清楚
    # 把 args 看成一个 list 
    def stu(*args):
        print("Hello,everybody.")
        # type 函数的作用是监测变量的类型
        print(type(args))
        for item in args:
            print(item)
    stu("LiuYang",19,"上海黄浦区","WangXiaojing","Single")
    stu("ZhouShengsheng")
    print("\n")

    # 参数收集案例
    # 说明收集参数可以不带任何实参调用，此时收集参数为空 tuple
    stu()

# - 收集参数之关键字收集参数
# ---- 把关键字参数按字典格式存入收集参数
# ---- 语法
#      def func(**kwargs):
#          func_body
#      # 调用
#      func(p1=v1,p2=v2,p3=v3,...)
# ---- 一般约定俗称使用 kwargs
# ---- 调用的时候，将多余的关键字参数放入 kwagrs
# ---- 访问 kwargs 需要按字典格式访问

    # 收集参数案例
    # 自我介绍
    # 调用的时候需要使用关键字参数调用
    def stu(**kwagrs):
        # 在函数体内针对 kwagrs 的使用无需带星号 **
        print("Hello,everybody.")
        print(type(kwagrs))
        # 对于字典的访问，python2 和 python3 有区别
        for k,v in kwagrs.items():
            print(k,"---",v)
            
        
    stu(name="JingTen",age=26,addr="GuangZhou",lover="Wangjing",work="IT")
    print("*"*40)    # 字符串的乘法
    stu(name="ZhouShengsheng") 
    print("*"*40)
    
    # 收集参数可为空案例
    stu()

# 收集参数混合调用的顺序问题
# - 收集参数，关键字参数，普通参数可混合使用
# - 使用规则：普通参数和关键字参数优先
# - 定义时一般找普通参数，关键字参数，收集参数 tuple,收集参数 dict

    # 收集参数混合调用案列
    # stu 模拟一个学生的自我介绍
    def stu(name,age,*args,hobby="No",**kwargs):
        print("Hello,everybody.")
        print("I'm {0},I'm {1} years old.".format(name,age))
        if hobby == "No":
            print("Sorry,I don't have hobby.")
        else:
            print("My hobby is {0}".format(hobby))
        print("*"*40)
        
        for i in args:
            print(i)
        print("-"*40)
        for k,v in kwargs.items():
            print(k,"---",v)
    
    # 开始调用函数
    name = "JingTen"
    age = 26
    stu(name,age)
    
    stu(name,age,hobby="photo")
    
    stu(name,age,"Dajiaonang","Yadan",hobby="python",hobby2="JingPingMei")  

    # 收集参数的解包问题
    # - 把参数放入 list 或者 dict 中，直接报 list/dict 中的值放入收集参数
    # - 在 list 或者 dict 前加 * 即可解包
    def stu(*args):
        print("Hahahahaha...")
        for i in args:
            print(i)
            
    stu("JingTen","Dajiaonang",26)
    print("*"*40)
    
    l = list()
    l.append("JingTen")
    l.append("Dajiaonang")
    l.append(26)
    print(l)
    print("*"*40)
    stu(l)    # 将 l 列表当成一个值传给 args
    print("*"*40)
    stu(*l)    # 将 l 列表解包后的值传递给 args