1.函数的定义及调用
函数：函数是将一段实现功能的完整代码，使用函数名称进行封装，通过函数名称进行调用。
以此达到一次编写，多次调用的目的
def get_sum(num): #num叫形式参数s=0for i in range(1,num+1):s+=iprint(f'1到{num}之间的累加和为：{s}')#函数的调用
get_sum(10) #1-10之间的累加和 10为实际参数
get_sum(100) #1-100之间的累加和
get_sum(1000) #1-1000之间的累加和
2.函数的参数传递
- 位置参数
是指调用时的参数个数和顺序必须与定义的参数个数和顺序相同
def happy_birthday(name,age):print('祝',name,'生日快乐')print(str(age),'岁生日快乐')#调用
happy_birthday('Jarvis',18)
结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-2位置参数.py
祝 Jarvis 生日快乐
18 岁生日快乐
- 关键字参数
是在函数调用时，使用 “形参名称=值” 的方式进行传参，传递参数的顺序可以与定义时参数的顺序不同
def happy_birthday(name,age):print('祝',name,'生日快乐')print(str(age),'岁生日快乐')#关键字传参
happy_birthday(age=18,name='Jarvis') #定义的形参分别为 age、name#happy_birthday(age=18,name1='Jarvis') #TypeError: happy_birthday() got an unexpected keyword argument 'name1'happy_birthday('张三',age=19) #正常执行，可以同时使用 位置传参和关键字传参#happy_birthday(name='Jarvis1',18) #SyntaxError: positional argument follows keyword argument
结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-3关键字传参的使用.py
祝 Jarvis 生日快乐
18 岁生日快乐
祝 张三 生日快乐
19 岁生日快乐
需要位置传参在前，关键字传参在后，否则程序报错
- 默认值参数
是在函数定义时，直接对形式参数进行赋值，在调用时如果该参数不传值，将使用默认值，如果该参数传值，则使用传递的值
def happy_birthday(name='Jarvis',age=18):print('祝',name,'生日快乐')print(str(age),'岁生日快乐')#调用
#不传参
happy_birthday()#传参一个
happy_birthday('张三') #位置传参happy_birthday(age=21)
结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-4默认值参数的使用.py
祝 Jarvis 生日快乐
18 岁生日快乐
祝 张三 生日快乐
18 岁生日快乐
祝 Jarvis 生日快乐
21 岁生日快乐
如果只传一个 19 呢？19会赋值给哪个变量呢？？？
happy_birthday(19)
祝 19 生日快乐
18 岁生日快乐
如果使用位置传参的方式，19传给了name
当位置参数和关键字参数同时存在时，位置参数一定要放前面！！ 位置参数在后会编译报错
def fun(a,b=20):passdef fun2(a=20,b): #报错了，语法错误 当位置参数和关键字参数同时存在时，位置参数在后会报错pass
3.可变参数
函数的参数传递: 又分为个数可变的位置参数和个数可变的关键字参数两种，
其中个数可变的位置参数是在参数前加 一颗星(*para), para 形式参数的名称
函数调用时刻接收任意个数的实际参数，并放到一个元组中。
个数可变的关键字参数是在参数前加 两颗星 (**para),
在函数调用时可以接受多个任意 “参数=值” 形式的参数，并放到一个字典中
- 个数可变的位置参数
def fun(*para):print(type(para))for item in para:print(item)fun(10,20,30,50)
fun(10)
fun(10,20)结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-5可变参数.py
<class 'tuple'>
10
20
30
50
<class 'tuple'>
10
<class 'tuple'>
10
20
如果可变参数是一个列表呢？？
fun([11,22,33,55])
<class 'tuple'>
[11, 22, 33, 55]
如果想把列表里面的每个参数逐步拿出来放在 元组里面，可以在调用时，参数面前加一颗星， 就能将列表进行解包
fun(*[10,20,30,88])
<class 'tuple'>
10
20
30
88
- 个数可变的关键字参数
def fun2(**kwpara):print(type(kwpara))for key,value in kwpara.items():print(key,'---->',value)#调用 fun2
fun2(name='JARVIS',age=19,height=173) #关键字参数
结果：
<class 'dict'>
name ----> JARVIS
age ----> 19
字典可以作为个数可变的关键字入参吗？？
# 定义一个字典
d = {'name': 'jarvis', 'age': 24, 'height': 173}
# fun2(d)#TypeError: fun2() takes 0 positional arguments but 1 was given
发现报错了
如果在进行传参时：定义的参数 是个数可变的关键字参数，那么在进行传参的时候，如果参数是个字典，前面必须加上两个星 进行解包
fun2(**d) # 解包
4.函数的返回值
def calc(a,b):print(a+b)calc(10,20)
print(calc(1,2)) #Nonedef calc2(a,b):s=a+breturn s #将s返回给函数的调用者去处理get_s=calc2(1,2)
print(get_s)get_s2=calc2(calc2(1,2),3) #1+2+3 先执行 calc2(1,2) 返回结果为3，再去执行 calc2(3,3)
print(get_s2)
返回值可以是多个：：
def get_sum(num):s=0odd_sum=0 #奇数和even_sum=0 #偶数和for i in range(1,num+1):if i%2!=0: #说明是奇数odd_sum+=ielse:even_sum+=is+=ireturn odd_sum,even_sum,s #三个值result=get_sum(10)
print(type(result)) # <class 'tuple'> 元组
print(result)
还可以 系列解包赋值：：
a,b,c=get_sum(10) #返回三个值，元组类型，分别赋值给 a,b,c
print(a)
print(b)
print(c)
5.匿名函数lambda
匿名函数：是指没有名字的函数，这种函数只能使用一次，
一般是在函数的函数体只有一句代码且只有一个返回值时，
可以使用匿名函数来简化
def calc(a, b):return a + bprint(calc(10, 20))# 简化：匿名函数
s = lambda a, b: a + b # s表示的就是一个匿名函数
print(type(s)) # <class 'function'># 调用匿名函数
print(s(10, 20))print('----------------分隔线---------')#
lst = [10, 20, 30, 50, 70]
for i in range(len(lst)):print(lst[i])
print()print('----------------分隔线---------')for i in range(len(lst)):result = lambda x: x[i] # 根据索引取值, result的类型是 functionprint(result(lst)) # lst是实际参数print('----------------分隔线---------')student_scores = [{'name': 'jarvis', 'score': 98},{'name': '张三', 'score': 60},{'name': '李四', 'score': 90},{'name': '王五', 'score': 45}
]
# 对列表进行排序，排序的规则是 字典中的成绩
student_scores.sort(key=lambda x:x.get('score'),reverse=True)
print(student_scores)
结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-9匿名函数.py
30
<class 'function'>
30
----------------分隔线---------
10
20
30
50
70----------------分隔线---------
10
20
30
50
70
----------------分隔线---------
[{'name': 'jarvis', 'score': 98}, {'name': '李四', 'score': 90}, {'name': '张三', 'score': 60}, {'name': '王五', 'score': 45}]
6.常用的数学函数
print('绝对值',abs(199),abs(-100),abs(0))print('商和余数',divmod(13,4))print('最大值',max('hello'))print('最大值',max([10,4,56,78,5]))print('最大值',min('hello'))print('最大值',min([10,4,56,78,5]))print('求和：',sum([10,3,55,6]))print('x的y次幂',pow(2,3))#四舍五入
print(round(3.1415926)) #round函数只有一个参数，保留整数print(round(3.1415926,2)) # 2 表示保留两位小数print(round(314.15926,-1)) #314 ， -1位 个位进行四舍五入print(round(314.15926,-2)) #300 -2 十位进行四舍五入
7.迭代器操作函数
- 排序操作
lst = [54, 56, 77, 3, 555, 789]# 排序操作
asc_lst = sorted(lst)
desc_lst = sorted(lst, reverse=True)print('原列表', lst)
print('升序', asc_lst)
print('降序', desc_lst)
结果：
D:\Python_Home\venv\Scripts\python.exe D:\Python_Home\chap8\示例8-13迭代器操作函数.py
原列表 [54, 56, 77, 3, 555, 789]
升序 [3, 54, 56, 77, 555, 789]
降序 [789, 555, 77, 56, 54, 3]
- reversed 反向
new_lst = reversed(lst)
print(type(new_lst)) # <class 'list_reverseiterator'> 迭代器对象
print(list(new_lst)) # [789, 555, 3, 77, 56, 54]
结果：
<class 'list_reverseiterator'>
[789, 555, 3, 77, 56, 54]
- (zip)
x = ['a', 'b', 'c', 'd']
y = [10, 20, 30, 40, 60]
zipobj = zip(x, y)
print(type(zipobj)) # <class 'zip'>
print(list(zipobj)) # [('a', 10), ('b', 20), ('c', 30), ('d', 40)]
结果：
<class 'zip'>
[('a', 10), ('b', 20), ('c', 30), ('d', 40)]
- enumerate
enum = enumerate(y, start=1)
print(type(enum)) # <class 'enumerate'>
print(tuple(enum)) # ((1, 10), (2, 20), (3, 30), (4, 40), (5, 60))
结果：
<class 'enumerate'>
((1, 10), (2, 20), (3, 30), (4, 40), (5, 60))
- all
lst2 = [10, 20, '', 30]
print(all(lst2)) # False, 空字符串的布尔值是 False
print(all(lst)) # True
- any
print(any(lst2)) # True
- next
x = ['a', 'b', 'c', 'd']
y = [10, 20, 30, 40, 60]
zipobj = zip(x, y)
print(next(zipobj)) #('a', 10)
print(next(zipobj))
print(next(zipobj))
