Python函数

最新推荐文章于 2022-12-07 23:55:13 发布

Divetime

最新推荐文章于 2022-12-07 23:55:13 发布

阅读量171

点赞数

分类专栏： python 文章标签： python pycharm list django virtualenv

本文链接：https://blog.csdn.net/weixin_52788247/article/details/119209005

版权

python 专栏收录该内容

16 篇文章 6 订阅

订阅专栏

1.函数基础

1.1函数的作用

函数： 是将实现固定功能的代码，聚合成函数，为此在使用是直接可以是调用函数就可以实现底代码的重复调用，进而实现缩减代码的书写时间。

1.2函数的使⽤步骤

第一步是函数的定义
函数定义的语法：

def 函数名(参数): 
	代码1 
	代码2 ......

第二步是函数的调用
函数的调用语法：

函数名(参数)

注意事项：

1.不同的需求，参数可有可⽆

2.在Python中，函数必须先定义后使⽤

1.3 函数的参数作⽤

函数的参数的作用：使代码更加灵活，函数的实用性更强
函数的实现的功能：两个数的加法.并返回计算结果
如1+1


#示例一
#函数的定义
def add_num1():
	return 1+1
#函数的调用
num1=add_num1()
print(num1)
#函数的定义
def add_num2(a,b):# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
	return a+b
#函数的调用
num2=add_num2(1,1)# 调⽤函数时传⼊了真实的数据1 和 1，真实数据为实参
num3=add_num2(2,3)
print(num2)
print(num3)

通过上述例子，可以知道函数add_num1（）只能是返回2，但是函数add_num2可以通过传入不同的参数值，进而计算这两个数的和，并返回该值

1.4函数的返回值作⽤

应用场景：例如：我们去购物，⽐如买‘王冰冰’，给钱之后，返回给我们‘王冰冰’，在函数中，如果需要返回结果给⽤户需要使⽤函数返回值

def buy():
	return '王冰冰'
print(buy())#此时的买的是‘王冰冰’，为此函数的返回值定义的是‘王冰冰’

1.5函数的说明⽂档

注释： 定义⼀个函数后，程序员能够快速提示这个函数的作用
函数的说明⽂档： 更⽅便的查看函数的作⽤（函数的说明⽂档也叫函数的⽂档说明）


def 函数名(参数): 
	""" 说明⽂档的位置 """ #定义说明文档
	代码 ......

help(函数名)#可以查看说明1文档的内容就是：""" 说明⽂档的位置 """中的内容

1.6函数嵌套

所谓函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数
示例：

def test1():
    print('这是函数1执行的内容')

def test2():
    test1()
    print('这是函数2执行的内容')

test2()#此时是调用函数2，但是此时函数2内部是使用了函数1，此时是函数的嵌套

执行结果：
在这里插入图片描述
#此时函数的执行流程是先执行函数test2,再执行函数内部的test1函数

1.7函数的使用

示例1：计算三个数的平均数

def average_num(num1,num2,num3):#定义函数
    sum_ret=(num1+num2+num3)/3
    return sum_ret


#调用函数

ret=average_num(1,2,3)
print(ret)#2

2.函数进阶

2.1变量作⽤域函数的

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量
局部变量： 定义在函数体内部的变量，即只在函数体内部⽣效
全局变量： 函数体内、外都能⽣效的变量

注意事项：
1.局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量，如果在函数外部使用该变量则会提示报错

示例1：

def test1():
    a=10
    print(a)

#print(a)#此时提示错误，a为函数内部定义的局部变量
test1()#20

示例2：

a=12#此时a为全局变量，所有的函数都是可以调用的
def test1():
    print(a)

def test2():
    print(a)


test1()#12
test2()#12

示例3：如何在函数体内部修改全局变量

a=12
def test1():
    a=100#此时是在函数的内部修改a的值但是实际上为修改全局变量a的值还是为12
    print(a)

def test2():
    global a#函数内部修改全局变量的值先定义再修改值
    a=200
    print(a)


test1()#100
test2()#200
print(a)#200

2.2多函数程序执⾏流程

⼀般在实际开发过程中，⼀个程序往往由多个函数（后⾯知识中会讲解类）组成，并且多个函数共享某些数据
1.共⽤全局变量

global_num=0

def test1():
    """是修改全局变量的函数"""
    global global_num
    global_num=100
    print(global_num)

def test2():
    """是打印全局变量的函数"""
    print(global_num)

print(global_num)
help(test1)#查看函数test1的功能
test1()
help(test2)#查看函数test2的功能
test2()

在这里插入图片描述

2.返回值作为参数传递

def test1():
    return 10

def test2(num):
    print(num)

ret=test1()#函数1的返回值作为函数2的参数
test2(ret)#10
#也可以直接是使用test2(test1())

2.3函数的返回值

1.两个return的执行结果

def test1():
    return 1#返回值为1
    return 2#返回值为2

print(test1())#1此时的输出结果为1是因为，在返回1后，函数直接结束运行，就不在执行return 2了

在这里插入图片描述

2.返回两个值return a,b

def test1():
    return 1 ,2

print(test1())#输出的是函数返回的值
print(type(test1()))#输出的是函数返回值的类型默认为元组

运行结果：
在这里插入图片描述

注意事项：

1. return a, b写法，返回多个数据的时候，默认是元组类型

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

2.4函数的参数

2.4.1位置参数

位置参数：调⽤函数时根据函数定义的参数位置来传递参数
示例：

def test1(name,age,gender):
    print(f'姓名是：{name},年龄是：{age},性别是：{gender}')

test1('zhangsan',29,'男')#此时输入的实参必须和函数的形参位置是一致的，否则数据在输出时的结果是与预期的是不符合的

在这里插入图片描述

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

2.4.2关键字参数

函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求
示例：

def test1(name,age,gender):
    print(f'你的名字是：{name},你的年龄是：{age}，你的性别是：{gender}')


test1(name='xiaoming',age=13,gender='男')
test1(gender='女',name='xiaofang',age=18)#此时的顺序就不重要了，只要是关键字正确就是可以的

输出的结果：
在这里插入图片描述
注意事项：如果有位置参数那么位置参数的位置，必须是位于关键字参数前面，但是关键字参数之间不存在顺序

2.4.3缺省参数

缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）
示例：

def test1(name,age,gender='男'):此时的缺省参数为gender默认为男
    print(f'你的名字是：{name},你的年龄是{age},你的性别是:{gender}')


test1(name='xiaoming',age=24)#如果不赋值则为默认值男
test1(name='xiaofang',age=18,gender='女')如果赋值则为新赋予的值

在这里插入图片描述
注意事项：函数在调用时，如果为缺省参数传值则修改默认参数值，否则还是使用这个默认值

2.4.4不定长参数

不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便

示例：

#不定长参数

def test1(*args):
    print(args)



test1('xiaoming',18,'男')
test1('xiaofang',18,'女',12343434)

运行结果：
在这里插入图片描述
注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递
示例2：

def user_info(**kwargs):
    print(kwargs)


user_info(name='xiaoming',age=18,gender='男')

运行结果：
在这里插入图片描述

2.5拆包和交换两个变量的值

拆包：
1.拆包：元组
示例：


def test1():
    return 10,20

num1,num2=test1()

print(num1)#10
print(num2)#20

2.拆包：字典
示例：


dict1={'name':'xiaoming','age':18}
a,b=dict1#此时拆包出来的是字典的key值

print(a)
print(b)

print(dict1[a])
print(dict1(b))

交换两个变量的值
1.用第三个变量


a=10
b=20
c=a
a=b
b=c
print(a)#20
print(b)#10

2.直接交换

a,b=10,20
a,b=b,a
print(a)#20
print(b)#10

2.6引用

在python中，值是靠引⽤来传递来的。我们可以⽤id()id()来判断两个变量是否为同⼀个值的引⽤。我们可以将id值理解为那块内存的地址标识。
示例：

a=1
b=a
print(b)#1
print(id(a))#1880759101744
print(id(b))#1880759101744
b=2
print(b)#2
print(id(b))#改变了为1880759101776

2.7可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.
可变类型
: 列表
: 字典
：集合

不可变类型

整型

浮点型

字符串

元组

3.学员信息管理系统

def info_print():
    """界面函数"""
    print('请选择功能-----------')
    print('1.添加学员')
    print('2.删除学员')
    print('3.修改学员')
    print('4.查询学员')
    print('5.显示所有的学员')
    print('6.退出系统')
    print('-' * 20)


info = []#存放学生信息的列表


def add_info():
    """添加学生信息函数"""
    global info#因为在函数内部修改全局变量先定义再修改
    new_id = input('请输入ID：')
    new_name = input('请输入姓名：')
    new_tel = input('请输入tel：')
    #先遍历再查看学生是否存在
    for i in info:
        if new_name == i['name']:
            print('此用户已经存在')
            return

    info_dict = {}#定义单个学生信息的列表，用于存放添加的学生信息
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel

    info.append(info_dict)#将一个学生的信息字典添加到学生信息的列表中
    print(info)


def del_info():
    """删除学生信息的函数"""
    del_name = input('请输入要删除的学生姓名：')

    global info#作用同上
    #遍历判断学生是否存在
    for i in info:
        if del_name == i['name']:
            info.remove(i)
            break
    else:
        print('该用户不存在')
    print(info)


def modify_name():
    """修改学生姓名的函数"""
    modify_name = input('请输入要修改的学生姓名：')

    global info#作用同上
    for i in info:
        if modify_name == i['name']:
            i['tel'] = input('输入要修改的手机号：')
            break
        else:
            print('要修改的用户不存在')
    print('info')


def search_info():
    """查询学生信息的函数"""
    search_name = input('请输入需要查询的学生姓名：')
    global info
    for i in info:
        if search_name == i['name']:
            print('查询到的信息如下：')
            print(f"id是{i['id']},姓名是：{i['name']},tel是：{i['tel']}")
            break
        else:
            print('查找的学生不存在')


def all_print():
    """打印所有的学生信息函数"""
    print('学号\t姓名\t电话\t')
    for i in info:
        print(f"学员的学号是：{i['id']},姓名是：{i['name']},电话是：{i['tel']}")

#通过循环可以重复执行该程序，直到输出指定命令是才可以退出程序的运行
while True:
    info_print()
    i = input('请输入（1-6）：')
    if i == '1':
        print('添加学员')
        add_info()
    elif i == '2':
        print('删除学员')
        del_info()
    elif i == '3':
        print('修改学员')
        modify_name()
    elif i == '4':
        print('查询学员')
        search_info()
    elif i == '5':
        print('显示所有的学员')
        all_print()
    elif i == '6':
        print('退出系统')
        exit_mess = input('请输入yes or no:')
        if exit_mess == 'yes':
            break
        break
    else:
        print('输入错误，请重新输入')

4.函数提高

4.1函数递归

1）递归的特点
函数内部⾃⼰调⽤⾃⼰
必须有出口
2）示例
求一个数的前n项和如n=10求1+2+3…+10

# 3 + 2 + 1
def sum_numbers(num): # 1.如果是1，直接返回1 -- 出⼝ 
    if num == 1: 
        return 1 # 2.如果不是1，重复执⾏累加并返回结果
    return num + sum_numbers(num-1)#这里使用的是函数的递归

num=int(input('请输入需要求的累加和数n:'))
sum_result = sum_numbers(num)# 如果输入3输出结果为6
print(sum_result)

执行流程：
在这里插入图片描述

4.2 lambda 表达式

1）lambda使用的场景：如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化
2）lambda语法：lambda 参数列表：表达式

注意事项：

lambda表达式的 参数可有可⽆，函数的参数在lambda表达式中完全适⽤

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

示例1：

def test():
    return 200

print(test())
print(test)#此时输入的是函数的地址

test1=lambda:200
print(test1)#此时输出的是lambda的地址
print(test1())

运行结果：
在这里插入图片描述
示例2：

#示例
#函数实现两个数的加法器

def add(num1,num2):
    return num1+num2

ret=add(10,20)
print(ret)#30
#lambda实现两个数的加法
add2=lambda num1,num2:num1+num2

ret2=add2(10,20)
print(ret2)#30

4.3 lambda表达式的参数

1）无参数
2）一个参数
3）默认参数
4）可变参数*args
5）可变参数kwargs **
示例：

ret1=lambda:200
print(ret1)
#一个参数

ret2=lambda num1:num1
print(ret2(100))
#默认参数

ret3=lambda num1,num2,num3=10:num1+num2+num3

print(ret3(10,20))#此时为40，num3默认为10
print(ret3(10,20,30))#此时为60，因num3重新赋值
#可变参数*args

ret4=lambda *args:args
print(ret4(10,20,30))
#可变参数**kwargs
ret5=lambda **kwargs:kwargs
print(ret5(name='xiaoming',age=19))

运行结果：
在这里插入图片描述

4.4高阶函数

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

示例：任意两个数字，按照指定要求整理数字后再进⾏求和计算

#法1
def abs_add(num1,num2):
    return abs(num1)+abs(num2)

ret1=abs_add(-19,20)
print(ret1)#39

#法2，就是高阶函数的使用案例，代码更加简洁
def abs_add1(num1,num2,f):
    return f(num1)+f(num2)

ret2=abs_add1(10,-10,abs)
print(ret2)#20

内置高阶函数	说明
map()	map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回
reduce()	reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算注意：reduce()传⼊的参数func必须接收2个参数
filter()	filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象。如果要转换为列表,可以使⽤ list() 来转换

1.map()示例

#计算列表中数据的的平方和
list1=[10,-19,20,1,2,-1]

def func(num):
     return num**2

ret =map(func,list1)
print(ret)
print(list(ret))#[100, 361, 400, 1, 4, 1]

2.reduce示例

import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b): 
	return a + b

result = functools.reduce(func, list1)
print(result) # 15

3.filter示例

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x): 
	return x % 2 == 0
result = filter(func, list1)
print(result) 
print(list(result)) # [2, 4, 6, 8, 10]

Divetime

关注

0
点赞
踩
1

收藏

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

python函数1.函数基础1.1函数的作用1.2函数的使⽤步骤1.3 函数的参数作⽤1.4函数的返回值作⽤1.5函数的说明⽂档1.6函数嵌套2.函数进阶2.1变量作⽤域函数的2.2多函数程序执⾏流程2.3函数的返回值2.4函数的参数2.5拆包和交换两个变量的值2.6引⽤2.7可变和不可变类型1.函数基础1.1函数的作用函数：是将实现固定功能的代码，聚合成函数，为此在使用是直接可以是调用函数就可以实现底代码的重复调用，进而实现缩减代码的书写时间。1.2函数的使⽤步骤第一步是函数的定义函数定义的
复制链接

扫一扫