Python——函数

#定义函数
def info_print():
    print('hello word!!!!')

def info_Print(scanner1,scanner2):
    print(scanner1,scanner2)

#调用函数
info_print()

info_Print('有参数函数','且参数不止一个')


# 两数字相加功能
def add(num1,num2):
    print(f'num1+num2 = {num1+num2}')

add(10,20)


# 函数返回值作用实验
def num(num1,num2):
    return num1*num2

result = num(10,10)
print(result)

函数说明文档

help(len) # help函数作用就是查看函数的说明文档（函数解释说明的信息）

定义函数说明文档：

格式：

def 函数名（参数）:
""" 说明文档的位置 """
代码1
代码2
......

查看函数的说明文档：

help(函数名) #会打印出说明文档信息

示例代码


def p(r):
    """
    说明文档：描述函数功能的说明文档测试。
    :param r: 参数1说明
    :return: 返回值说明
    """
    return r

p1 = p('函数说明文档调用测试')
print(p1)

help(p)

函数嵌套调用

函数中嵌套调用了函数

示例代码

'''
def a():
    print('我是a函数')

def b():
    print('我是b函数')
    a()  # 嵌套

b()  # 嵌套调用

函数体内部修改全局变量

先 global 声明a是全局变量，然后再变量重新赋值

如果函数中需要书写多个返回值时，值之间用逗号隔开

例如：

def retu():
return 1,2,3,4,5,6,7,8,9,10

注意：

1.此时的返回值默认为元组类型

2.return后面可以连接列表，元组或字典，以返回多个值

3.仅需要某一个返回值时，只需按照索引下标调用

例如： re = 函数返回值此时第一个返回值： re[0]

示例代码


a = 100
def g():
    global a
    a = 300

print(a)
g()
print(a)


def retu():
    return 1,2,3,4,5,6,7,8,9,10
re = retu()
print(re)
print(re[0])
print(re[1])
print(re[2])
print(re[9])

位置参数

1.位置参数：

调用函数时根据函数定义的参数位置来传递参数

注意：传递的参数和定义参数的顺序及个数必须一致

2.关键字参数：

函数调用时通过’键=值‘的形式加以指定，可以让函数更加清晰容易使用，同时也清除了参数的顺序需求

注意：函数调用时如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

例如： def re(name,age,gender):
调用： re(name='小张',age='12',gender='男')

3.缺省参数：

也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值

注意：所有位置参数必须出现在默认参数前面，包括函数定义和调用

例如： def re(name,age,gender='男')

调用： re('Tom',23) 此时可默认缺省参数，不写
re('Tom',23,'女') 当为缺省参数传值时，代表修改默认参数值，否则使用这个默认值

4.不定长参数：

也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
此时可用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

1.包裹位置传递：

def re(*args): # args只是变量，不固定
print(args)
re('Tom')
re('Tom',12)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple）
args是元组类型，这就是包裹位置传递

2.包裹关键字传递：

def re(**kwargs):
print(kwargs)

re(name='长安',age='23',id='004') # {'name':'长安','age':23,'id':004}

注意：返回值是字典类型

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

示例代码

def arg(*args):
    print(args)

arg('长安')
arg('长安',12)
arg('长安',12,87,178)

def kwarg(**args):
    print(args)

kwarg(name='阿茶',age=23,id='004')

拆包和交换变量值

拆包：元组

def re():
return 100,200
num1,num2 = re()
print(num1) # 100
print(num2) # 200

拆包：字典

对字典进行拆包，取出来的是字典的key值

dict1 = {'name':'Tom','age':32}
a,b = dict1
print(a) # name
print(b) # age
print(dict1[a]) # Tom
print(dict1[b]) # 32

交换变量值

方法一

借助第三变量存储数据：定义中间变量存储其中一个，后一个进行交换

c = 0
c = a a = b
b = c

方法二

a,b = 1,2

a,b = b,a
或者： a = 1
b = 2
a,b = b,a

引用

在python中，值是靠引用来传递的
可以用id()来判断两个变量是否为同一个值的引用，id值可以理解为那块内存的地址标识

--------int型数据为不可变类型
--------list列表型数据为可变类型

示例代码

a = 100
print(a)
print(id(a))  # 140714380292016
a += a          # a = a + a
print(a)
print(id(a))  # 140714380295216

递归

递归: 一种编程思想

特点：

1.函数内部自己调用自己
2.必须有出口

示例代码


# 递归实现3以内数字的累加和
def sum(num):
    if num == 1:
        return 1     # 递归的出口
    return num+sum(num-1)

i = sum(4)
print(i)
j = sum(10)
print(j)

lambda表达式

应用场景：如果一个函数有一个返回值，并且只有一句代码，可以使用lambda表达式进行简化

语法：

lambda 参数列表 : 表达式

注意：

1.lambda表达式的参数可有可无，函数的参数在lambda表达式内完全适用

2.lambda表达式能接收任何数量的参数但只能返回一个表达式的值

例如：

def re():   # 无参
retrun 200

def re(num1,num2):   # 有参
retrun 200

lambda表达式：

re = lambda:200 # 无参
re = lambda num1,num2 : 200 # 有参

默认参数情况：

re = lambda a,b,c=10:a+b+c

可变参数情况

*args: 传入lambda表达式后返回值为元组

可变参数情况

**kwargs: 传入lambda表达式后返回值为字典

带判断的lambda表达式

re = lambda a,b: a if a > b else b # 输入两参数判断大小，a>b时返回a,否则返回b

列表数据按字典key的值排序

students = [
{'name':'Tom','age':21},
{'name':'Rose','age':22},
{'name':'Jec','age':25},
{'name':'Steve','age':23},
]

按name值升序排列：

students.sort(key=lambda x:x['name'])
print(students)

按name值降序排列：

students.sort(key=lambda x:x['name'],reverse=True)
print(students)

按age值升序排列：

student.sort(key=lambda x:x['age'])
print(students)

示例代码

def re():
    return 1
print(re)
print(re())

r1 = lambda:200
print(r1)            # 直接打印lambda表达式，输出的是lambda表达式的内存地址
print(r1())
r2 = lambda num1,num2:num1+num2
print(r2(10,20))

r3 = lambda *args:len(args)
print(f'r3可变参数的个数：{r3(1,2,3,4,5,6,7,8,9,10)}')

r4 = lambda *args:args
r5 = lambda **kwargs:kwargs
print(r4(10,20,30,40))
print(r5(name='python',chinese='中国',age='23',id='004'))


r6 = lambda a,b: a if a > b else b
print(r6(200,50))


students = [
    {'name': 'Tom', 'age': 21},
    {'name': 'Rose', 'age': 22},
    {'name': 'Jec', 'age': 25},
    {'name': 'Steve', 'age': 23},
]
print(f'正常初始：{students}')

students.sort(key=lambda x:x['name'])
print(f'name升序：{students}')

students.sort(key=lambda x:x['name'],reverse=True)
print(f'name降序：{students}')

students.sort(key=lambda x: x['age'])
print(f'age升序：{students}')

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现，函数式编程就是指这种高度抽象的编程范式

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快

Python中

abs()函数可以完成对数字绝对值计算

abs(-10) # 10

round()函数可以完成对数字的四舍五入计算

round(1.2) # 1
round(1.9) # 2

高阶函数例如：

def sum_num(a,b,F):
return F(a)+F(b)
result = sum_num(-1,3,abs)
print(result) # 4

步骤解析：

因为传入的第三个参数是函数abs,
即： return abs(-1)+abs(3)

Python内置高阶函数：

lst表示列表序列

map(func,lst):

将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表（Python2）/迭代器(Python3)返回

简单理解：就是lst的每个变量都要经过func的处理

reduce(func(x,y),lst):

其中func必须拥有两个参数，每次func计算的结果继续和序列的下一个元素做累积计算

注意：

1.reduce()传入的参数func必须接受2个参数

2.使用reduce()方法必须导入functools模块

filter(func,lst):

函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象，如果要转换为列表，可以使用list()转换

示例


def sum_num(a, b, F):
    return F(a) + F(b)

result = sum_num(-1, 3, abs)
print(f'result={result}')



list1 = [1,2,3,4,5]
def func(i):
    return i**2
result = map(func,list1)
print(result)              # <map object at 0x000002E2FCD03F60>
print(list(result))        # [1, 4, 9, 16, 25]




import functools   # 导入functools模块   使用reduce()方法必须导入functools模块
list1 = [1,2,3,4,5]
# 计算list1中各个数据的累加和
def func(a,b):
    return a+b
result = functools.reduce(func,list1)
print(result)    # 15    即：1+2+3+4+5=15




list1 = [1,2,3,4,5,6,7,8,9,10]
def func(x):
    return x%2 == 0    # 返回偶数
result = filter(func,list1)    # func此时为返回偶数过滤奇数规则
print(result)   # <filter object at 0x000002DC65EA3AC8>
print(list(result))   # [2, 4, 6, 8, 10]

数据-流

关注

9
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Python——函数

def 函数名（参数）:代码1代码2......格式：def 函数名（参数）:""" 说明文档的位置 """代码1代码2......查看函数的说明文档：help(函数名) #会打印出说明文档信息示例代码def p(r):"""说明文档：描述函数功能的说明文档测试。:param r: 参数1说明:return: 返回值说明"""return rp1 = p('函数说明文档调用测试')print(p1)help(p)
复制链接

扫一扫