Python函数进阶

最新推荐文章于 2024-07-27 12:20:46 发布
最新推荐文章于 2024-07-27 12:20:46 发布
阅读量322 收藏
点赞数
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YuanXiaoHei88/article/details/126115570
版权

文章目录

1. 函数返回值

  1. 什么是返回值
    返回值从函数内部传递到函数外部的数据，python中的每个函数都可以传递一个数据到函数的外部。
  2. 怎么确定函数返回值
    return后面的值就是函数的返回值。（在执行函数体时，如果遇到return，return后面的值就是返回值。
  3. 怎么获取函数返回值
    获取函数调用表达式的值就是函数的返回值。
    函数调用表达式：调用函数的语句
  4. 什么时候使用返回值
    如果实现函数功能，产生新的数据，就将新的数据作为函数的返回值返回。
def func1(a, b):
    result = a + b
    return result
    # 获取函数的返回值
print（func1(10, 20)）
# 30

想要把多个数据返回，可以在return后面写多个数据，
函数调用表达式的值就是函数的返回值，返回值能干的事情，函数调用表达式都可以做。

def func2(a, b):
    result1 = a + b
    result2 = a * b
    print(result1, result2)
    return result1, result2
# 函数调用表达式，是有结果的表达式
func2(1, 23)
# 24 23

return会提取结束函数，遇到return函数直接结束

def func3():
    print('----')
    return
    print('+++')
func3()
# ----

提取大写字母

def func4(str):
    new_str=''
    for i in str:
        if i.isupper():
            new_str+=i
    return new_str
print(func4('jJQ'))
# JQ

2. 变量作用域

变量在定义完成后可以使用的范围。根据变量作用域的不同，可以将变量分为全局变量和局部变量。

  1. 全局变量
    没有定义在函数里面或者类里面的的变量都是全局变量。
    作用域：从定义开始，到程序结束，（程序结束前的任何位置都可以使用）
  2. 局部变量
    定义在函数中的变量是局部变量。（形参也是局部变量，定义在类中的变量是属性）
    作用域：从定义开始到函数结束。

2.1 全局变量

案例1：a是全局变量，可以直接使用a。

a = 10
print(f'外面的{a}')

for i in range(1):
    print(f'循环里面{a}')


def func1():
    print(f'函数里的{a}')


func1()
# 外面的10
  循环里面10
  函数里的10

案例2：x b 全局变量 没有放在循环和函数里

for x in range(5):
    b = 20
print(f'外面x和b:{x},{b}')


def func2():
    print(f'函数里的{x},{b}')


func2()
# 外面x和b:4,20
  函数里的4,20

2.2 局部变量

案例3：c和d是局部变量

def func3(c):
    d = 30
    print(f'函数里的{c},{d}')


func3(4)
# 函数里的4,30

2.3 存储方式

全局变量默认保存在全局栈区间（程序结束时才会被释放）
局部变量默认是保存在函数对应的临时栈区间，创建函数时候会自动创建出来，函数调用结束会自动释放。
在函数中定义变量时，可以在定义变量前加global关键字，让函数中定义的变量可以保存在全局栈区间。

x = 100    # 保存全局栈区间

def func4():
    y = 200    # 保存在func4对应的临时栈区间

    global z
    z = 300     # 保存在全局栈区间中


func4()
print(f'外面z:{z}')
# 外面z:300

如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明

name = '小明'     # name是全局变量，保存在全局栈区间


def change_name():
    # name = '小花'     # 重新创建一个局部变量name，保存在change_name对应的临时栈区间中
    # print(f'函数里面name：{name}')

    global name
    name = '小花'
    print(f'函数里面name：{name}')


change_name()


print(f'外面name：{name}')

3. 函数参数的确定

  1. 调用函数的时候，实参应该给什么样的数据，由参数在函数体中的使用方式决定。
  2. 实参高阶函数 - 函数的参数是函数
    如果一个参数是函数，传参的时候又两种方法1） 用普通函数的函数名2）使用匿名函数。
    func6这个函数的参数要求是函数， 这个func6就是一个实参高阶函数。
def func6(x):
    # x = temp
    x()     # temp()

def temp():
    print('临时函数')

func6(temp)
# 临时函数

x必须是函数，有一个参数，返回值必须是数字

def func7(x):
    # x = temp2
    print(x(10) + 20)           # print(temp2(10) + 20)   ->  print(19 + 20)


def temp2(m):
    # m = 10
    return 19


func7(temp2)
# 19

4. 匿名函数

  1. 只能实现简单的功能
    语法：
    函数名 = lambda 形参列表：返回值
    相当于：
    def 函数名（形参列表）：
    return 返回值
    案例：定义一个函数求两个数的和
sum2 = lambda num1, num2: num1 + num2
print(sum2(12, 33))
# 45
  1. 匿名函数的应用
    在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)
def func1(x):
    print(x(10, 20) + 10)


#x是一个函数；有两个参数，有一个数字对应的返回值
def temp1(m, n):
    return 12.3


func1(temp1)


func1(lambda m, n: 12)
# 22.3
  22

5. 实参高阶函数

  1. max、min、sorted
    1）max（序列） 直接比较序列中元素的大小，求出最大值。
    2）max（序列，key=函数） 按照函数制定的比较规则比较元素的大小，求出最大值。
    函数的要求：a.有且只有一个参数（代表序列中每个元素），b.需要一个返回值（返回值是比较对象，将参数看成元素，在这个地方来描述比较对象和元素之间的关系）
    案例1 求nums中最大的元素
nums = [12, 23, 46, 19]
result = max(nums, key=lambda item: item)
print(result)
# 46

#案例2 求个位数最大值的元素

nums = [12, 23, 46, 19]
result = max(nums, key=lambda item: item % 10)
print(result)
# 19

案例3 求students中年龄最大的学生

students = [
    {'name': '明', 'age': 23},
    {'name': '花', 'age': 13, }
]
result = max(students, key=lambda item: item['age'])
print(result)
# {'name': '明', 'age': 23},

练习1 求nums中十位数最大的元素:

nums = [23, 34, 67, 60]
result = max(nums, key=lambda item: item // 10 % 10)
print(result)
# 67

练习2 求nums中绝对值最小的元素

nums = [-992, 46, 21, -44]
result = min(nums, key=lambda item: abs(item))
print(result)
# 21

练习3：nums中各个位数之和最大的元素

nums = [102, 19, 48, 221, 52]
# 3,10,12,5,7  ->  48
# 102  -> '102'  -> '1'、'0'、'2'

# 方法一：
result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(result)
# 方法二：
def temp(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1


result = max(nums, key=temp)
print(result)

练习4:将students中的元素按照分数从高到低排序

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
result = sorted(students, key=lambda i: i['score'], reverse=True)
print(result)
# 方法2
students.sort(key=lambda i: i['score'], reverse=True)
print(students)
  1. map
    基于原序列的元素创建新序列。
    map（函数，*序列 ） 根据函数制定规则，将制定序列中的元素转换成新序列中的元素。
    函数的要求：a.有且只有一个参数，序列有几个就有几个参数
    b.有返回值，返回对应的是新序列中的元素。
    案例1：创建一个列表，列表中的元素是num是中所有元素的个位数
nums = [12, 34, 67, 44]
result = map(lambda item: item % 10, nums)
print(list(result))
# [2, 4, 7, 4]

案例2：两个列表元素求和

A = [3000, 5600, 9800, 4200, 10000]
B = [1500, 1000, 2200, 1300, 3200]
result = map(lambda i1, i2: i1 + i2, A, B)
print(list(result))
# [4500, 6600, 12000, 5500, 13200]

练习1：所有元素乘10

nums = [23, 45, 11, 54]
result = map(lambda i: i * 10, nums)
print(list(result))

练习2：基于scores创建一个列表，列表中元素根据nums中元素确定为’及格’或者’不及格’

scores = [82, 67, 89, 66, 90, 23, 71]
result = map(lambda i: '及格' if i >= 60 else '不及格', scores)
print(list(result))
# ['及格', '及格', '及格', '及格', '不及格', '及格']

练习3：基于names、ages和scores，创建学生列表：

names = ['stu1', 'stu2', 'stu3', 'stu4']
ages = [23, 34, 19, 22]
scores = [82, 67, 89, 66]
# [{'name': 'stu1', 'age': 23, 'score': 82}, .....]
result = map(lambda i1, i2, i3: {'name': i1, 'ages': i2, 'scores': i3}, names, ages, scores)
print(list(result))
  1. reduce
    合并序列，将序列中所有的元素通过制定的规则合并成一个数据。
    reduce(函数，序列，默认值）
    函数的要求：a.有且只有两个参数（第一个参数指向默认值，第二个参数指向序列中每个元素）
    b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中的元素得到的。
    默认值为0求和，为一求乘积，空值为序列
    使用之前导入
    from functools import reduce
    案例1：求nums中所有元素的和
nums = [10, 20, 30, 40]
result = reduce(lambda i, item: i + item, nums, 0)
print(result)

案例2：求nums中所有元素的乘积

nums = [10, 20, 30, 40]
result=reduce(lambda i, item:i*item,nums,1)
print(result)

案例3：求所有元素个位数和

nums = [23, 78, 92, 78, 12]
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)

案例4：将所有元素合并成一个字符串：‘2378927812’

nums = [23, 78, 92, 78, 12]
result=reduce(lambda i , item :i + str(item),nums,'')
print(result)

案例5：求所有学生的总分

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
result=reduce(lambda i,item:i+item['score'],students,1)
print(result)
# 428

练习题

  1. 写一个匿名函数，判断指定的年是否是闰年

    year = lambda num1: (num1 % 4 == 0 and num1 % 100 != 0) or num1 % 400 == 0
print(year(2009))

  2. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

    result2 = lambda x: list(x[-i-1] for i in range(len(x)))
print(result2([1,2,3]))

  3. 编写一个函数，计算一个整数的各位数的平方和

    例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14

def sum(num1):
    num2 = 0
    num1 = str(num1)
    for i in num1:
        num2 += int(i) ** 2
    print(123)

  4. 求列表 nums 中绝对值最小的元素

    例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-23

result = min(nums, key=lambda i: abs(i))
print(result)

  5. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

    A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
新字典: {'name': '张三', 'age': 18, 'sex': '女'}

result = map(lambda key, value: (key, value), A, B)
print(dict(result))

  6. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

    names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}

result = map(lambda i1,i2,i3: (i1,i3+i2), names,nums,subjects)
print(dict(result))

  7. 已经一个列表message, 使用reduce计算列表中所有数字的和

    message = ['你好', 20, '30', 5, 6.89, 'hello']
结果：31.89

result = reduce(lambda i, item: i + (item if type(item) == int or type(item) == float else 0), message, 0)
print(result)

  8. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）

    points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

    1）获取列表中y坐标最大的点

    result=max(points,key=lambda y :y[1])
print(result)

    2）获取列表中x坐标最小的点

    result=min(points,key=lambda x :x[0])
print(result)

    3）获取列表中距离原点最远的点

    result = max(points, key=lambda max1: abs(max1[0] ** 2 + max1[1] ** 2))
print(result)

    4）将点按照点到x轴的距离大小从大到小排序

    result = sorted(points, key=lambda x: x[0]**2)
print(result)
yviul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机语言python函数进阶
05-09
Python函数进阶 多参数解析 使⽤ `*args`（元组） 和 `**kwargs` （字典）来调⽤函数 使用`*args`非关键字可变参数方式 # 以元祖方式传递 nums = (1, 2, 3) 使用`**kwargs`关键字可变参数方式 # 以字典...
04.python函数进阶.md
05-10
04.python函数进阶.md
python函数进阶
springbear的博客
12-01 582
python函数进阶笔记
第七章 Python-函数进阶
计算机网络技术
06-06 877
网络自动化运维-Python函数进阶
第七章 Python函数进阶
weixin_64953311的博客
04-19 463
按照返回值的顺序，写对应顺序的多个变量接受即可变量之间用逗号隔开支持不同类型的数据return。
python函数进阶篇笔记
2301_81135589的博客
05-13 389
（3）缺省参数：也叫默认参数，用于定义函数，为参数提供默认值，调用函数时不可传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数的定义和调用）注：参数是“键=值”的形式的情况下，所有的“键=值”都会被kwargs接收，同时会根据“键=值”组成字典。注：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。（4）不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。（1）位置参数：调用函数时根据函数定义的参数位置来传递参数。
Python:函数进阶
weixin_62735525的博客
12-06 699
五分钟学会函数的进阶
Python基础第六篇（Python函数进阶）
Du_XiaoNan的博客
01-22 390
在本篇技术型博客中，我们将深入探讨Python函数的各种细节。首先，我们会讨论函数的多返回值，这是Python语言中一个非常重要的特性。随后，我们将精心分析函数参数的各类形式：位置参数、关键字参数、缺省参数以及不定长参数。每个参数类型都会通过具体的代码示例进行详细解析。
python 函数进阶-闭包函数
小可爱的博客
04-10 2147
闭包函数 什么是闭包函数 如果内函数使用了外函数的局部变量，并且外函数把内函数返回出来的过程叫做闭包，里面的内函数是闭包函数。 # 外函数 outer def outer(): # 外函数变量 num var = '外函数局部变量' # 内函数 inner def inner(): # 内函数使用了外函数的变量 num print('内函数使用了：' + var) # 外函数将使用了外函数的局部变量的内函数返回 return inner # 返回出的结果就是内函数 inner，现在
Python函数进阶篇！
Mr_chen的博客
10-21 516
Python函数进阶篇！ 今天博主跟大家聊一聊如何使用Python函数进阶篇！不喜勿喷，如有建议欢迎补充、讨论！ 关于安装和汉化可以观看博主的这篇文章《下载安装及汉化 》以及Python系列：windows10配置Python3.0开发环境！，安装完毕重启VsCode！以及VSCode配置Python开发环境！ Come on！篇幅总结 在了解完了 Python函数基础篇 之后，本篇的存在其...
python 函数进阶与参数处理
qq_43626653的博客
01-21 349
接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。#调用函数，把不同数量的参数传递进去，用位置参数。接收任意多个实际参数，并将其放到一个元组中。
python函数进阶之匿名函数
Beck_k的博客
07-18 148
【代码】python函数进阶之匿名函数。
Python进阶.pdf
04-11
《Python进阶》是一本专为已经掌握Python基础的开发者准备的进阶指南。书中涵盖了Python编程中的高级特性和实践技巧，旨在帮助读者深入理解Python的内在机制，并提升编程效率和代码质量。以下是对书中部分关键知识点...
笨办法学python的进阶篇，学习更多python
10-15
而“进阶篇”则是针对已经掌握了Python基础的读者，旨在帮助他们进一步提升技能，深入理解Python的高级特性以及在实际项目中的应用。 首先，Python进阶学习的重点在于对语言特性的深度理解和熟练运用。例如，元组、...
Python语法进阶
12-22
前面我们已经学习了Python的基础语法，了解了Python的分支结构，也就是选择结构、循环结构以及函数这些具体的框架，还学习了列表、元组、字典、字符串这些Python中特有的数据结构，还用这些语法完成了一个简单的名片...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
最新发布
qq_64603703的博客
07-27 729
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1009
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 585
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值