python-函数（上）：函数返回值、函数调用、前向引用

编程方法：

1、面向对象：类--class
2、面向过程：过程--def
3、函数式编程：函数--def

# python中函数
# 函数的定义
# 打印一个佛祖镇楼 -> 一个功能点的解释
def print_info():print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\ = /O  ")
    print("                        ____/`---'\____  ")
    print("                      .   ' \| |// `.  ")
    print("                       / \||| : |||// \  ")
    print("                     / _||||| -:- |||||- \  ")
    print("                       | | \\\ - /// | |  ")
    print("                     | \_| ''\---/'' | |  ")
    print("                      \ .-\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\ `. . __  ")
    print("                ."" '< `.___\_<|>_/___.' >'"".  ")
    print("               | | : `- \`.;`\ _ /`;.`/ - ` : | |  ")
    print("                 \ \ `-. \_ __\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖镇楼                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  写字楼里写字间，写字间里程序员；  ")
    print("                  程序人员写程序，又拿程序换酒钱。  ")
    print("                  酒醒只在网上坐，酒醉还来网下眠；  ")
    print("                  酒醉酒醒日复日，网上网下年复年。  ")
    print("                  但愿老死电脑间，不愿鞠躬老板前；  ")
    print("                  奔驰宝马贵者趣，公交自行程序员。  ")
    print("                  别人笑我忒疯癫，我笑自己命太贱；  ")
    print("                  不见满街漂亮妹，哪个归得程序员？")
a = 10
if a == 10:
    # pass 占位 防止语法错误
    print_info()
# 函数 -> python

函数是逻辑结构化和过程化的一种编程方法
python中函数定义方法：

def test(x):
　　"The function definitions"
　　x+=1
　　return x

def：定义函数的关键字
test :函数名
（）：内可定义形参
“”：文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值

#函数
def func1():
    "testing1"
    print("in the func1")
    return 0
#过程
def func2():
    "testing2"
    print("in the func2")
x = func1()  # in the func1
y = func2()  # in the func2
print("from func1 return is %s"%x)  # from func1 return is 0
print("from func2 return is %s"%y)  # from func2 return is None

使用函数的三大优点：
1.代码重用
2.保持一致性
3.可扩展性

函数返回值
返回值数=0:返回None（没有return的情况）
返回值数=1:返回object
返回值数>1:返回tuple(返回一个元组)

如：

def test01():
    pass
def test02():
    return 0
def test03():
    return 0,10,'Hello',['alex','lb'],{'WuDaLang':'lb'}
t1 = test01()
t2 = test02()
t3 = test03()
print("from test01 return is [%s]:"%type(t1),t1)
print("from test01 return is [%s]:"%type(t2),t2)
print("from test01 return is [%s]:"%type(t3),t3)

函数调用
调用方法：通过 函数名() 即可完成调用
test()执行，()表示调用函数test，()内可用有参数也可以没有

注意：

• 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
• 当然了如果函数中执行到了return也会结束函数

参数：
1.形参和实参

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与形参一一对应）
实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参
区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

# 定义一个有参数的函数
# 形参: 形式参数
# 格式: def 函数名(形参1, 形参2, ...):
def my_func(a, b):
    ret = a + b
    print(ret)
# 执行一个有参数的函数
# 实参: 实际参数
# 格式: 函数名(实参1, 实参2,...)
num1 = 80
num2 = 9
# 在执行函数的时候 就好比是a = num1 b = num2
my_func(num1, num2)

2.位置参数和关键字（标准调用：实参和形参位置一一对应；关键字调用：位置无需固定）

def test(x,y):
    print(x)
    print(y)
test(1,2)     #位置参数调用，实参的位置与形参的位置要一一对应
test(y=2,x=1) #关键字参数，调用函数的时候使用的是函数的形参名，与形参顺序无关
test(3,y=2)   #混合使用时，位置参数在前，关键字参数在后，关键字参数是不能写在位置参数前面的

3.默认参数（缺省参数）: 给形参设置了一个默认值

def test(x,y=2):
    print(x)
    print(y)
test(1)
test(1,y=3)
test(1,3)
#默认参数特点：调用函数的时候，默认参数非必须传递

4.参数组

# *args: 接受N个位置参数，转换成元组形式
def test(*args):    #参数不固定
    print(args)
test(1,3,2,4,5)
test(*[1,2,4,5,5])  #args = tuple([1,2,4,5,5])
def test1(x,*args):
    print(x)
    print(args)
test1(1,2,3,4,5,6,7)

# **kwargs:接受N个关键字参数，转换成字典的方式
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])
    print(kwargs['sex'])
test2(name='alex',age=8,sex='F')
test2(**{'name':'alex','age':8,'sex':'F'})
def test3(name,**kwargs):
    print(name)
    print(kwargs)
test3('alex')     #后面接收一个空字典
test3('alex',age=18,sex='m')
def test4(name,age=18,**kwargs):   #参数组要放后面
    print(name)
    print(age)
    print(kwargs)
test4('alex',sex='m',hobby='tesla')
test4('alex',5,sex='m',hobby='tesla')
test4('alex',sex='m',hobby='tesla',age=3)
def test5(name,age=18,*args,**kwargs):   #参数组要放后面
    print(name)
    print(age)
    print(args)
    print(kwargs)
test5('alex',age=34,sex='m',hobby='tesla')

函数返回值

# python 学习了 一个内置函数 len(object)
# 定一个字符串
my_str = "hello"
# 内置函数如何实现的
def my_len(object):
    ret = 0
    for i in object:
        ret += 1
    # 如果有一个return 数值 成为这个函数有返回值
    return ret
my_l = my_len(my_str)
# None 没有返回值 空值类型
print("自定义的:",my_l)  # 自定义的: 5
l = len(my_str)
print(l)  # 5

# 四种函数的类型
# 01- 无参数无返回值
def my_print():
    print("你好")
    print("python")
# 执行函数
my_print()
# 02- 无参数有返回值
def my_pi():
    return 3.1415926
print(my_pi())
# 03- 有参数无返回值
def print_info(name):
    print("你好%s" % name)
print_info("龟叔")
# 04- 有参数有返回值def my_func(a, b):
    return a - b
result = my_func(10, 5)
print(result)

函数返回值之多个return

• 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

• 如果程序设计为如下，是可以的因为不同的场景下执行不同的return

# 包含多个return
def my_func(score):
    if score < 0:
        print("您传入的分数有误!!!")
        return          # 函数的执行提前结束
    print("测试")
    # 对分数进行判断
    if score >= 90:
        return "优"
    elif score >= 80:
        return "良"
    elif score >= 60:
        return "中"
    elif score >= 0:
        return "差"
    print("测试")      # 不会执行 因为在前面已经执行了return
# 提出需求 如果调用函数的人 传入的分数小于0 那么就人为传入的分数错误 告知函数的调用者
my_func(-10)

函数返回多个数据

• return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
• 如果return后面有多个数据，那么默认是元组

# 需求 传入一个人名字 和年龄，例如 小明 22
# 通过调用函数后 得到两个字符串 姓名:小明  年龄:22
# 列表
def deal_name_age(name, age):
    # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    return [new_name, new_age]
# 变量为列表
ret = deal_name_age("小明", 22)
print(ret[0])
print(ret[1])
# 字典
def deal_name_age(name, age):
    # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    return {"name":new_name, "age":new_age}
my_dict = deal_name_age("小明", 22)
print(my_dict["name"])
print(my_dict["age"])
# 元组
def deal_name_age(name, age):
    # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    # 如果在函数内部 使用return 返回值1 返回值2,... 默认就是元组类型 不需要写小括号
    return new_name, new_age
my_tuple = deal_name_age("小明", 22)
print(type(my_tuple))  # <class 'tuple'>
print(my_tuple[0])  # 姓名:小明
print(my_tuple[1])  # 年龄:22

函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

def my_func1():
    print("my_func1开始")
    print("my_func1结束")
def my_func2():
    print("my_func2开始")
    my_func1()
    print("my_func2结束")
# 执行函数
my_func2()
"""
# 最终打印结果
my_func2开始
my_func1开始
my_func1结束
my_func2结束
"""

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

前向引用
函数action体嵌套某一函数logger，该logger的声明必须早于action的调用，否则报错

def action():
    print("in the action")
    logger()
action()
def logger():
    print("in the logger")
#报错：NameError: name 'logger' is not defined

def logger():
    print("in the logger")
def action():
    print("in the action")
    logger()
action()

def action():
    print("in the action")
    logger()
def logger():
    print("in the logger")
action()