4.Python函数基础(上)
1、函数的基础
Python函数：基本上所有的高级语言都支持函数，Python也不例外。Python不仅可以非常灵活的定义函数，而且本身内置了很多有用的函数(内置函数)，可以直接调用。
函数就是最基本的一种代码抽象的方式，也可以认为函数是面向对象的一种体现(封装)。
概念：在编写程序的过程中，有某一功能代码出现多次，但是为了提高代码的编写效率以及避免代码的重复使用，可以把具有独立功能的代码块组织为一个小模块，这就是函数。
函数的定义：
def 函数名称(参数列表):
功能代码块
函数的调用：函数名加()即可调用该函数，本质上就是去执行函数定义里面的代码块，再调用之前必须先定义。
函数说明文档：函数内容的第一行可以用字符串进行函数说明。
# 多次输出学生的个人信息(代码冗余)
print("Mack的身高是%.2fcm" % 1.73)
print("Mack的体重是%.2fkg" % 75)
print("Mack的爱好是%s" % "唱歌")
print("Mack的专业是%s" % "计算机科学与技术")
print('- - '*8, '第二次输出相同的信息', '- - '*8)
print("Mack的身高是%.2fcm" % 1.73)
print("Mack的体重是%.2fkg" % 75)
print("Mack的爱好是%s" % "唱歌")
print("Mack的专业是%s" % "计算机科学与技术")
# 多次打印小张的信息(使用函数可以精简优化代码)
# 方案：封装函数
def PrintInfo(): # 函数的定义
# 函数说明文档(备注信息)
'''
这个函数是用来打印个人信息的。
'''
# 函数代码块(独立的功能)
print("Mack的身高是%.2fcm" % 1.73)
print("Mack的体重是%.2fkg" % 75)
print("Mack的爱好是%s" % "唱歌")
print("Mack的专业是%s" % "计算机技术")
# 调用函数、多次调用，每次调用都是独立的
print('- - '*16)
PrintInfo() # 函数的调用
print('- - '*16)
PrintInfo() # 多次调用
# 查看函数的说明文档
print(PrintInfo.__doc__)
print(help(PrintInfo))
# 进一步精简多次打印个人信息的函数功能
def PrintInfo(n): # 函数的定义
for i in range(n):
print('- - '*8, '第%d次输出相同的信息' % (i+1), '- - '*8)
print("Mack的身高是%.2fcm" % 1.73)
print("Mack的体重是%.2fkg" % 75)
print("Mack的爱好是%s" % "唱歌")
print("Mack的专业是%s" % "计算机技术")
print()
# 打印3次个人信息
PrintInfo(3)
2、函数的参数
定义函数的时候，就要把参数的名字和位置确定好，函数的接口就完成了。对于函数的调用时，只需要知道如何传递正确的参数，以及函数将返回什么样的值就可以。
Python的函数定义非常简单，灵活度大，除了正常定义的必选参数外，还可以使用默认参数、可变参数、关键字参数，多样的参数可以让函数处理复杂的问题，还可以简化代码。
缺省参数：在调用函数时如果没有传参数，那么就会使用定义函数时给的缺省值，缺省参数必须在参数列表的最后面，否则会报错。
不定长参数：一个函数有时会处理比当初声明的参数多的情况，定义函数时可以不用声明参数名。用加了*号的变量args存放所有未命名的变量参数，args为元组。用加了**号的kwargs存放命名参数，即key=value的参数，kwargs为字典。
引用传参：Python中函数参数是引用传递(不是值传递)，对于不可变类型，因变量不可改变，所以运算不会影响到变量自身。对于可变类型，函数体中的运算有可能会改变传入的参数变量。
# 输出不同人的信息
# 方案：通过传入参数来解决
def PrintInfo(name, height, weight, hobby, major): # 必选参数
"""
打印个人信息。
"""
print("%s的身高：%.2fcm" % (name, height))
print("%s的体重：%.2fkg" % (name, weight))
print("%s的爱好：%s" % (name, hobby))
print("%s的专业：%s" % (name, major))
print('- - '*16)
# 调用带参数的信息
PrintInfo("Jack", 1.73, 75, "唱歌", "计算机科学与技术")
PrintInfo("Peter", 1.80, 80, "打游戏", "游戏运营与策划")
参数的分类：必须参数、默认参数(缺省参数)、可选参数、关键字参数
参数：其实就是函数为了实现特定的功能，参数就是为了实现功能所需要的外部数据(得到外部数据)
# 1 必选参数
def sum1(a, b): # 形式参数(形参)：只是意义上的参数(标记)，在定义的时候不占用内存地址
'''
加法运算。
'''
sum1 = a+b
print(sum1)
# 函数的调用
sum1(20, 15) # 实际参数(实参)：有具体值的参数，实际占用内存地址
# 2 默认参数(缺省参数)
def sum1(a=10, b=20):
print("默认参数1的使用=%d" % (a+b))
# 函数的调用
sum1() # 不赋值时的使用，使用缺省的值
sum1(25) # 只给一个值，赋值给第一个参数
sum1(25, 1) # 给两个值，重新赋值给函数
print('- - '*8)
# 默认参数(缺省参数)必须在参数列表的最后面，否则会报错
def sum2(a, b=15):
print("默认参数2的使用=%d" % (a+b))
sum2(25)
sum2(2, 6)
# 3 可选参数(不定长参数)，当参数的个数不确定时使用
def getComputer(*args):
'''
计算累加和。
:param args: 可变的参数类型
'''
result = 0 # 定义一个数据，用来存储结果
print('元组类型的数据:', args) # 打印接收的数据，元组类型的数据
for item in args:
result += item
print("累加和为：%d" % result)
getComputer(1)
getComputer(1, 2, 3, 4, 5)
# 4 关键字可变参数(不定长参数)，在函数体内是一个字典类型，key的键是一个字符串
def keyFunc(**kwargs):
print(kwargs)
# 调用函数
# keyFunc(1, 2, 3) # 错误的传参方式
dictA = {"name": "Leo", "age": 35}
keyFunc(**dictA) # 直接传入一个字典对象，前面必须加上**
keyFunc(name="Peter", age=45) # 以命名参数的方式直接传入参数
keyFunc() # 不传任何参数
# 5 不定长参数混合使用，定义参数时的位置不能改变，必须是*args, **kwargs
def complexFunc(*args, **kwargs):
'''
可选参数必须放在关键字参数之前
可选参数：元组
关键字参数：字典
'''
print(args)
print(kwargs)
print('- - '*16)
complexFunc()
complexFunc(1, 2, 3, 4)
complexFunc(age=36)
complexFunc(1, 2, 3, 4, name="Peter", age=45)
3、函数的返回值
返回值(return)：程序中的函数完成一个事件后，返会一个结果，否则返回None，可以返回任意类型(取决于 return 后面的类型)。
在一个函数体中可以出现多个return值，但只能返回一个return。
如果在一个函数体中执行了return，则函数执行完毕(退出)，return后面的代码语句不会再执行。
def sum1(a, b):
result = a + b
return result # 将计算的结果返回
print(sum1(10, 20)) # 函数的返回值返回到调用的地方
rs = sum1(22, 55) # 将返回值赋值给其他的变量对象
print(rs) # 函数的返回值返回到调用的地方
# 计算累加和
def calComputer1(num):
result = 0
i = 1
while i <= num:
result += i
i += 1
return result
value = calComputer1(100)
print(type(value))
print(value)
def calComputer2(num):
result = 0 # 存储计算结果
listA = []
i = 1
while i <= num:
result += i
i += 1
listA.append(result)
return listA
value = calComputer2(100)
print(type(value))
print(value)
# 返回元组类型的数据
def reTuple():
return 1, 2, 3
re = reTuple()
print(type(re))
print(re)
# 返回字典类型的数据
def reDict():
# return 1,2,3
return {"name": "Loe"}
re = reDict()
print(type(re))
print(re)
4、函数的嵌套调用
函数嵌套调用：在一个函数的内部调用另外一个函数，内层函数可以访问外层函数中定义的变量，但不能重新赋值(rebind)。
# 函数嵌套
def Func1():
print("* * * * Func1 Start * * * *")
print("* * * * 执行代码 * * * * ")
print("* * * * Func1 End * * * * ")
def Func2():
print("- - - - Func2 Start- - - -")
# 嵌套调用第一个Func1函数
Func1()
print("- - - - Func2 End - - - -")
Func2()
# 计算n的阶乘：使用递归思想
def factorial(n):
if n == 1:
return 1
return n * factorial(n-1)
print(factorial(5))
5、练习
# 1 接收n个数字，求这些参数数字的和
def CalSum1(*args):
result = 0
for i in args:
result += i
return result
result = CalSum1(1, 2, 3, 6667, 44, 321, 5, 102, 7, 8, 15)
print("求和的结果是:%d" % (result))
def CalSum2(*args):
result = sum(args)
return result
result = CalSum2(1, 2, 3, 6667, 44, 321, 5, 102, 7, 8, 15)
print("求和的结果是:{}".format(result))
# 找出传入的列表或元组的奇数下标位对应的元素，并返回一个新的列表
def FindNewList(oe, seq):
new_list = []
ends = len(seq)
for i in range(oe, ends, 2):
element = seq[i]
new_list.append(element)
return new_list
listA = FindNewList(0, (None, "abcd", 89, 19.3, "你好", True,
1, [1, 12, 2, 33], 22, {"name": "Loe"}))
print("返回偶数位下标的结果:{}".format(listA))
listB = FindNewList(1, [None, "abcd", 89, 19.3, "你好", True,
1, [1, 12, 2, 33], 22, {"name": "Loe"}])
print("返回奇数位下标的结果:{}".format(listB))
def process_Func(con):
listNew = []
index = 0
for i in con:
if index % 2 == 1:
# if index % 2 == 0:
listNew.append(i)
index += 1
return listNew
listA = process_Func((None, "abcd", 89, 19.3, "你好", True,
1, [1, 12, 2, 33], 22, {"name": "Loe"}))
print("返回奇数位的结果:{}".format(listA))
# 检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
# 字典中的value只能是字符串或列表
def CheckDict(seq):
for key, value in seq.items():
seq[key] = value[:2] # 下标会越界(报错)，切片不会！！！
return seq
Dict = CheckDict({'name': '欧阳慕容', 'id': ['唱歌', '游泳', '打游戏', '跳舞'],
'sex': 'F', 'address': '地球亚洲中国'})
print(Dict)
def dictFunc(dictParms):
result = {}
sup_result = {}
for key, value in dictParms.items():
if len(value) > 2:
sup_result[key] = value
result[key] = value[:2]
else:
result[key] = value
return sup_result, result
SupDict, Dict = dictFunc({'name': '欧阳慕容', 'id': ['唱歌', '游泳', '打游戏', '跳舞'],
'sex': 'F', 'address': '地球亚洲中国'})
print(SupDict)
print(Dict)
总结
函数的基本定义、参数的定义、函数的返回值以及嵌套函数的例子。
扫一扫
675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
