Python入门-函数

1.函数的定义及调用

函数：函数是将一段实现功能的完整代码，使用函数名称进行封装，通过函数名称进行调用。

以此达到一次编写，多次调用的目的

def get_sum(num):   #num叫形式参数
    s=0
    for i in range(1,num+1):
        s+=i
    print(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):
    pass

def fun2(a=20,b):  #报错了，语法错误    当位置参数和关键字参数同时存在时，位置参数在后会报错
    pass

3.可变参数

函数的参数传递: 又分为个数可变的位置参数和个数可变的关键字参数两种，
其中个数可变的位置参数是在参数前加 一颗星(*para), para 形式参数的名称
函数调用时刻接收任意个数的实际参数，并放到一个元组中。
个数可变的关键字参数是在参数前加 两颗星 (**para),
在函数调用时可以接受多个任意 “参数=值” 形式的参数，并放到一个字典中

1. 个数可变的位置参数

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

2. 个数可变的关键字参数

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))  #None

def calc2(a,b):
    s=a+b
    return 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=0
    odd_sum=0 #奇数和
    even_sum=0 #偶数和
    for i in range(1,num+1):
        if i%2!=0:  #说明是奇数
            odd_sum+=i
        else:
            even_sum+=i
        s+=i
    return 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 + b


print(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的类型是 function
    print(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.迭代器操作函数

1. 排序操作

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]

2. 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]

3. (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)]

4. 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))

5. all

lst2 = [10, 20, '', 30]
print(all(lst2))  # False, 空字符串的布尔值是 False
print(all(lst))  # True

6. any

print(any(lst2))  # True

7. 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))