java调用python获取返回值_Python全栈之路-7-函数

本文代码

lookenwu/learnpython​github.com

函数定义

函数是组织好的，可重复使用的，用于执行特定任务的代码块，函数能提高代码的模块性，Python本身提供的函数称为内置函数，用户自己创建的函数称为自定义函数

在Python中使用def定义函数，函数定义格式如下

def 函数名(函数参数):
    函数逻辑
    return 返回值

函数可以有参数，也可以没有参数，函数如果有返回值时需要通过return返回相应的返回值，如果没有返回值则不需要return语句

# 定义一个无参数，无返回值的函数
def simple():
    """该函数既无参数也无返回值"""
    print("我是一个无参数，无返回值的函数")
    
# 通过函数名加()调用函数
simple()

我是一个无参数，无返回值的函数
# 定义一个有参数有返回值的函数
def sumn(n):
    """
    该函数既有参数，也有返回值
    该函数的作用是，输入一个正整数n，返回从0到n之和
    """
    if n < 1:
        return 0
    total = 0
    for x in range(n+1):
        total += x
    return total

n = 100
print("从0到{}的和为: {}".format(n, sumn(n)))

从0到100的和为: 5050
# 定义一个带默认值参数的函数
def addn(x, n=1):
    """
    函数还可以定义参数的默认值
    默认值参数必须放到参数列表后面
    该函数的作用是输入x，返回x+n，且n的默认值为1
    """
    return x + n

# 等价于调用addn(100, 1)
print(addn(100))

# 显式传递参数
print(addn(100, 99))

# 还可以通过关键字参数调用函数，即明确指定参数和参数的值
print(addn(x=200, n=99))

101
199
299

*args

通过*args可以向函数传递可变个数参数，其表现形式类似序列类型

def add_args(*args):
    """该函数实现的逻辑是将所有输入参数累加求和并返回"""
    total = 0
    for val in args:
        total += val
    return total

# 可以向函数传递可变个数参数
print(add_args(23, 65))
print(add_args(1, 3, 5, 7, 99))
print(add_args(22, 53, 6, 98, 21, 30, 59, 73, 20, 37))

88
115
419

**kwargs

通过**kwargs可以向函数传递可变个数的键值对参数，其表现形式类似字典类型

def language_resp(**kwargs):
    """该函数实现的逻辑是将输入的键值对参数全部输出"""
    for lang, resp in kwargs.items():
        print("{} -> {}".format(lang, resp))
        
lang = {
    "python": "人生苦短，我用Python",
    "c++": "awesome",
    "java": "shit",
    "js": "ugly",
    "php": "传说中最好的编程语言???",
    "go": "let'go"
}

language_resp(**lang)

python -> 人生苦短，我用Python
c++ -> awesome
java -> shit
js -> ugly
php -> 传说中最好的编程语言???
go -> let'go

lambda

可以用lambda关键字来创建匿名函数，lambda函数在可以在需要函数对象的任何地方使用.

# 定义一个lambda函数，计算输入值的平方
square = lambda x: x*x

print(square(3))
print(square(5))

9
25
def get_addn(n=1):
    """返回一个lambda对象，该lambda输入参数为x，返回值为x+n"""
    return lambda x: x + n

# 输入参数为默认值n=1，调用该lambda对象将获取比输入参数大1的值
add_one = get_addn()
print(add_one(99))

# 输入参数为n=10，调用该lambda对象将获取比输入参数大10的值
add_ten = get_addn(n=10)
print(add_ten(99))

100
109
# 自定义排序时时常会使用lambda函数自定义排序规则
items = [(1, "one"), (3, "three"), (5, "five"), (2, "two"), (4, "four")]
# 使用元组的第一个元素排序
items.sort(key=lambda x : x[0])
print(items)

[(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four'), (5, 'five')]
# 使用元组第二个元素排序
items.sort(key=lambda x : x[1])
print(items)

[(5, 'five'), (4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

函数进阶

在Python中，函数也是对象，函数可以作为其它函数的参数或返回值. 参数或返回值是函数的函数称为高阶函数.

import functools

def add(x, y):
    return x + y

def minus(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    if y == 0:
        raise ZeroDivisionError("除数不能为0")
    return x / y

def calculator(x, y, op):
    """函数作为参数"""
    return op(x, y)

x = 5
y = 3

# 把函数作为参数传递到其它函数中
print("{} + {} = {}".format(x, y, calculator(x, y, add)))
print("{} - {} = {}".format(x, y, calculator(x, y, minus)))
print("{} * {} = {}".format(x, y, calculator(x, y, multiply)))
print("{} / {} = {}".format(x, y, calculator(x, y, divide)))

5 + 3 = 8
5 - 3 = 2
5 * 3 = 15
5 / 3 = 1.6666666666666667
def operator(op):
    """函数作为返回值"""
    def add(x, y):
        return x + y

    def minus(x, y):
        return x - y

    def multiply(x, y):
        return x * y

    def divide(x, y):
        if y == 0:
            raise ZeroDivisionError("除数不能为0")
        return x / y
    
    if op == "+":
        return add
    elif op == "-":
        return minus
    elif op == "*":
        return multiply
    elif op == "/":
        return divide
    else:
        raise ValueError("函数参数错误")
        
# 从其它函数返回函数对象
fadd = operator("+")
fminus = operator("-")
fmultiply = operator("*")
fdivide = operator("/")

x = 5
y = 3
print(fadd(x, y))
print(fminus(x, y))
print(fmultiply(x, y))
print(fdivide(x, y))

8
2
15
1.6666666666666667
def user_id(user_name, uid, sep):
    """使用分隔符将用户名和用户id拼接起来"""
    return user_name + sep + str(uid)

# 我们还可以通过partial返回一个新的函数对象，且可以指定原函数的部分参数
uname = functools.partial(user_id, sep="#")
print(uname("张三", 666666)) # 等价于调用user_id("张三", 666666, "#")
print(uname("李四", 999999)) # 等价于调用user_id("李四", 999999, "#")

张三#666666
李四#999999
# functools.partial用于普通函数
# functools.partialmethod用于类内定义的方法

class UserId:
    @staticmethod
    def user_id(user_name, uid, sep):
        """使用分隔符将用户名和用户id拼接起来"""
        return user_name + sep + str(uid)
    uname = functools.partialmethod(user_id, sep="#")
    
u = UserId()
print(u.uname("张三", 666666)) # 等价于调用UserId.user_id("张三", 666666, "#")
print(u.uname("李四", 999999)) # 等价于调用UserId.user_id("李四", 999999, "#")

张三#666666
李四#999999