之前简单写了一篇文章,描述了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实战编程
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
