python函数的定义,python lambda函数的定义

之前简单写了一篇文章,描述了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关键字"));

---

2021-03-02更新;
线上昨天炸了一个下午,搞得都没时间摸鱼学python了,今天还分了更新迭代的开发任务,gouride领导;

12.python定义lambda函数以及使用(这个比Java就简单多了)

# 简单定义lambda函数 关键字lambda,这个函数在各种语言中都有,python中的相对而言简单一点;
sumAmount = lambda x,y:x+y;
print(sumAmount(1,2));

13.python中使用lambda定义闭包函数;

# 定义闭包的lambda函数
def testLambdaFunction(inputNumber):
    return lambda inputNumber2: inputNumber + inputNumber2;


testLambda = testLambdaFunction(100);
print(testLambda(100));

14.python中的主函数

# python不需要定义主函数就可以直接执行各种程序,这点和Java有很大的差异,但是python也内置了主函数,如下;
def testMain():
    print("我是python的主函数调用");


if __name__ == '__main__':
    testMain()

完整的函数定义代码如下;

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


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


print(testFunction(name="1", age="1"));


# 注意这个函数中间多了个*号
def testFunction(name, age, *, sex):
    print('姓名是：' + name, "年龄是：" + str(age), "性别是：" + str(sex));
    return 3;


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


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


print(testFunction1("张三"));


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


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


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


# 定义了字典参数类型的函数,在对应参数面前加** 拿取元组中的数据可以通过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="男");


# 定义了字典参数类型的函数,在对应参数面前加** 拿取元组中的数据可以通过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="男");


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


print(sum(100))

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


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


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


# 函数内部定义函数
# 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));


# 函数内部定义函数 测试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关键字"));

# 简单定义lambda函数 关键字lambda,这个函数在各种语言中都有,python中的相对而言简单一点;
sumAmount = lambda x, y: x + y;
print(sumAmount(1, 2));


# 定义闭包的lambda函数
def testLambdaFunction(inputNumber):
    return lambda inputNumber2: inputNumber + inputNumber2;


testLambda = testLambdaFunction(100);
print(testLambda(100));


# python不需要定义主函数就可以直接执行各种程序,这点和Java有很大的差异,但是python也内置了主函数,如下;
def testMain():
    print("我是python的主函数调用");


if __name__ == '__main__':
    testMain()


# python内置的函数
"""
    callable()函数,判断函数是否可以被调用,可以返回true,失败返回false,(我第一眼看到还以为和Java中的多线程一样,没想到差距好大);
    例：callable(testMain);
    
    eval()函数,将程序作为字符串执行,只可以执行单行程序,有返回参数;
    例：eval("1 + 2");
    可以定义元组,集合,字典;
    例：eval([1,2,3]);
    
    exec()函数,将程序作为字符串执行,可以执行多行和单行字符串程序,没返回参数;
    例：str = "for item in range(1,10,2):" \
                "print(item,end='、')"
       result = exec(str);
       print(result);
       
    
    eval和exec这两个函数感觉和Java中的反射意思一样,我们不谈具体的实现,
    这两个函数的定义也是在系统运行时才进行编译和执行,
    用的多了肯定对系统的性能消耗是非常大的,
    如果要解决性能问题,
    那么需要提前对程序进行编译即可--使用compile()函数;
    因为是刚学python,不知道有什么具体的应用场景,感觉是python的骚操作,专门为了秀的;
    
    compile()函数 可以动态编译所需要执行的代码,有三种操作模式;
        model = "eval":     编译后的代码使用eval()函数执行处理,只允许执行单行代码;
            有返回值,单行计算表达式返回结果;
        model = "single":   编译后的代码使用exec()函数执行处理,定义单行表达式,此操作允许交互式的处理,执行单行代码：
            没有返回值,可以定义全局变量,对全局变量进行操作;
        model = "exec":     编译后的代码使用exec()函数执行处理,定义多行代码,
    
    例：
        # model = "eval":
        str = "100 + 100 + 100";
        compile三个入参,依次代表,执行的程序,执行的文件名字,使用什么模式
        testCompile = compile(str,"","eval"); #定义变量对象
        result = eval(testCompile); #执行代码
        print(result);
        
        # model = "single": 
        str = None;
        testCompile = compile("str = 1","","single");
        eval(testCompile); #执行代码
        print("str变量参数修改为{}".format(str));
        
        # model = "exec":
        str = "for item in range(1,10,2):" \
                "print(item,end='、')"
        testCompile = compile(str,"","exec");
        eval(testCompile); #执行代码
"""

上述函数的定义和学习来源于csdn中的视屏教学–python实战编程