python函数的定义

之前简单写了一篇文章,描述了python中的循环和函数等,可能不是很详细,这里再扩展一下python函数的其他定义方式;

1.python中的函数定义是def关键字开头的;

# 函数定义 def关键字 后面是函数的名字
def funcName():
    print("python语言的第一个函数");

2.python和Java一样有无参有参的函数

# 无参函数,没返回值,但是python默认没有return的函数返回None;
def funcName():
    print("python语言的第一个函数");

# 有参函数,有返回值;
def testFunction(name, age):
    print('姓名是：' + name, "年龄是：" + str(age));
    return 3;

3.python定义了函数,有返回值,想要指定参数传递

def testFunction(name, age):
    print('姓名是：' + name, "年龄是：" + str(age));
    return 3;

# 调用
print(testFunction(name="1", age="1"));

4.python定义了函数,前面的不想指定传递,后面的想要指定参数传递;

# 注意这个函数中间多了个*号  命名关键字函数,这种函数定义不清楚有什么应用场景,感觉是个鸡肋;
def testFunction(name, age, *, sex):
    print('姓名是：' + name, "年龄是：" + str(age), "性别是：" + str(sex));
    return 3;


print(testFunction("1", 1, sex=1));

5.python定义函数,可以设置默认值,这个时候调用方不需要进行参数的传递,如果定义了默认值,调用方也传递了参数,那么会覆盖掉默认值的参数,这个比较灵活;(默认值参数定义必须定义在非默认值后面,否则会报错)

# 定义了默认值age1,被调用方可以不传递对应参数,否则必须传递,不然会报错
def testFunction1(name, age = 1):
    print(name, age);


print(testFunction1("张三"));

# 错误示例
def testFunction1(age = 1,name ):
    print(name, age);

6.python定义元组作为入参函数;

# 定义了元组参数类型的函数,在对应参数面前加* 拿取元组中的数据可以通过for循环,也可以使用下标进行数据的拿取;
def testFunction2(name, *names):
    print(name, names);


testFunction2("张三",1,2,3,4,5);

7.python定义字典作为入参函数;

# 定义了字典参数类型的函数,在对应参数面前加** 拿取元组中的数据可以通过for循环
def testFunction3(name, **Map):
    print("姓名是:{},map中的元素为：{}".format(name,Map) )
    print("遍历Map中的数据结果为------------------");
    for key,value in Map.items():
        print(f"key = {key},value = {value}");


testFunction3("张三", age=1, sex="男");

8.python定义多类型参数作为入参,这种用的比较少；

# 定义了字典参数类型的函数,在对应参数面前加** 拿取元组中的数据可以通过for循环
def testFunction4(name, *List, **Map):
    print("姓名是:{},元组中的元素为：{},map中的元素为：{}".format(name, List, Map))
    print("遍历Map中的数据结果为------------------");
    for key, value in Map.items():
        print(f"key = {key},value = {value}");


testFunction4("张三", 1, 2, 3, 4, age=1, sex="男");

9.递归函数,如果这种方式难以理解就使用for循环,下面的代码意思就是1到100每个数字相加得到的和,这种使用的比较少;

# 测试递归函数 和Java差不多,自己调自己,但是需要设定一个return的界限,否则会内存溢出;
def sum(num):
    if num == 1:
        return 1;
    return num + sum(num - 1);


print(sum(100));

10.函数中修改全局变量的值,使用global关键字;

# 在函数中如何使用全局变量
test_num = 1;


def change_num():
    global test_num;
    test_num = 2;
    print("局部变量数据为：{}".format(test_num));


change_num();
print("全局变量数据为：{}".format(test_num));

11.函数内部定义函数

# 函数内部定义函数
# outer_add外部函数 当你调用这个函数的时候传递了参数a,之后会调用内部函数进行实际的逻辑处理,和Java一样
def outer_add(a):
    def inner_add(b):
        return a + b;
# 返回内部函数,这里必须有,否则会报错
    return inner_add;


# 函数outer_add可以简单定义为oa;
oa = outer_add(100);
# outer_add函数中的a已经定义为了100,那么再调用简化的oa函数时,此时的oa中的变量20其实是inner_add(b)中的b的参数了
print(oa(20));

12.函数内部定义,如何在内部函数使用外部函数的参数;

# 函数内部定义函数 测试nonlocal关键字 这里不可以使用global,两个关键字的含义不同
def outer_add(num_a):
    def inner_add(num_b):
        nonlocal num_a;
        num_a += 1;
        return "测试第：{}次进入函数，内容为：{}".format(num_a,num_b);

    return inner_add;


# 函数outer_add可以简单定义为oa;
oa = outer_add(0);
print(oa("测试nonlocal关键字"));
print(oa("测试nonlocal关键字"));