函数的进阶

最新推荐文章于 2024-09-04 20:18:34 发布
最新推荐文章于 2024-09-04 20:18:34 发布
阅读量42 收藏
点赞数
文章标签： python numpy 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65216324/article/details/129697447
版权
本文详细介绍了Python中的函数使用，包括return的作用，函数作用域（全局变量与局部变量），以及匿名函数（lambda）的使用。此外，还讲解了实参高阶函数如max、min和sorted的运用，以及如何通过全局变量和局部变量的交互。最后，讨论了迭代器的概念及其特性。
摘要由CSDN通过智能技术生成

函数进阶

一、return的补充

return的作用

1)将数据作为函数的返回值返回

2)结束函数(执行函数体时，如果遇到return，函数直接结束)

注意：return只能在函数体中使用

def func2():
    print('+++++++')
    return
    print('-------')
    print('=======')

def func1(n):
    for i in range(1,n):
        if i % 3 == 0:
            return i
        print(f'i:{i}')
print(func1(5))


from random import shuffle
num = [19, 89, 79]
shuffle(num)
print(num)

二、变量作用域

  1. 变量作用域

    变量作用域指的是变量定义完成后可以使用的有效范围
    根据变量作用域的不同，可以将变量分为全局变量和局部变量两种

  2. 全局变量和局部变量

    1)全局变量
    Python中没有定义在函数中或者类中的变量默认都是全局变量
    作用域：从定义开始到程序结束

    2)局部变量
    Python中定义在函数中的变量就是局部变量
    作用域：从定义开始到函数结束

    # 全局变量
# a是全局变量
a = 100

# x和b都是全局变量
for x in range(5):
    b = 200


print(f'外面使用a:{a}')
print(f'外面使用x:{x}')
print(f'外面使用b:{b}')

for y in range(3):
    print(f'循环里面a:{a}')
    print(f'循环里面b:{b}')
    print(f'循环里面x:{x}')


def fun1():
    print(f'函数里面a:{a}')
    print(f'函数里面b:{b}')
    print(f'函数里面x:{x}')

fun1()

# m 和 n 是局部变量
def func2(m):
    n = 1000
    print(f'函数里面m:{m}')
    print(f'函数里面n:{n}')

func2(100)

  3. 全局变量和局部变量的存储原理

    1)全局变量默认保存全局栈区间，在程序结束后会自动释放
    2)临时栈区间，用来保存在函数中产生的数据（局部变量就是保存在函数对应的临时栈区间中，函数对应的临时栈区间会在函数调用结束时自动释放）
    调用函数的时候系统会自动为这个函数创建一个临时栈区间，用来保存在函数中产生的数据(局部变量
    就是保存在函数对应的临时栈区间中的)，函数对应的临时栈区间会在函数调用结束的时候自动释放。
    3)在函数中可以通过关键字global修改局部变量的保存方式，让局部变量保存在全局栈区间中。

name = '小明' # 全局变量

def func3():
    # 在函数内部定义全局变量用global
    global num
    num = 10

    # 在函数内部修改全局变量的值用global
    global name
    name = '小花'


func3()

print(num)
print(name)

def func3():
    global num  #将局部变量修改成全局变量
    num = 10

# 在函数内部修改全局变量的值

三、匿名函数

匿名函数 - 没有名字(函数名)的函数

语法：

函数名(变量名) = lambda 形参列表:返回值
相当于：
def 函数名(形参列表):
return 返回值

注意：

1)匿名函数的形参至少一个
2)匿名函数的调用和普通函数一样
3)无默认值的类型说明在匿名函数中不能用

# 案例：定义一个匿名函数，求任意两个数的和
sum_1 = lambda num1,num2:num1+num2
# sum_1 = lambda num1=1,num2=2:num1+num2

result = sum_1(100,100)
print(result)

result = sum_1(num1=100,num2=100)
print(result)

# result = sum_1()
# print(result)

# 练习：定义一个匿名函数，判断指定的年是否是闰年
is_leap_year = lambda year:(year % 4 == 0 and year % 100 != 0) or year % 400 == 0
result = is_leap_year(2008)
print(result)

四、实参高阶函数

实参高阶函数定义：一个函数的参数是函数，的函数就是实参高阶函数

传参数是函数的函数的参数的方式：a.使用普通函数的函数名；b.使用匿名函数

重点：掌握系统或者第三方库提供的实参高阶函数的用法

# 常见的实参高阶函数：max min sorted 列表.sort map reduce
def func1(x):
    print(x)


func1(10)
func1('abc')
func1([10, 20])
func1({'a': 10})


def func2(x):
    print(x * 2)


func2(10)
func2(1.23)
func2('abc')
func2([10, 20])
func2((100, 200))


def func3(x):
    print(x + 10)


func3(100)
func3(1.23)
func3(True)


def func4(x):
    print(x[1])


func4('abc')
func4([10, 20])
func4({1: 100, 'a': 200})


def func5(x):
    print(x.split('+'))


func5('abc')

def func1(x):
    x()
def t():
    print('t函数')
func1(t)


def func2(x):
    print(x(10, 20)+30)
def t2(n1, n2):
    return n1 * n2
func2(t2)
func2(lambda n1, n2: n1 + n2)

五、常见的高阶函数

  1. max min sorted 列表.sort

    1)max(序列) - 直接比较序列中列表元素的大小求最大值
    2)max高级用法 - max(序列,key=函数) - 按照函数制定的规则比较序列值元素的大小获取最大值
    函数要求：
    a.有且仅有一个参数(此参数代表序列中的每个元素)
    b.有一个返回值(返回值就是比较对象)

    # 案例：求个位数最大的元素
nums = [83, 67, 19, 22, 80, 77, 93]
result = max(nums, key=lambda item: item % 10)
print(result)       # 19

# 案例：求nums中绝对值最大的元素
nums = [8, -283, 89, 100, 82, -34]
result = max(nums, key=lambda item: item ** 2)
print(result)       # -283
# 案例：求students中分数最高的学生
students = [
    {'name': 'stu1', 'age': 18, 'score': 90},
    {'name': 'stu2', 'age': 22, 'score': 98},
    {'name': 'stu3', 'age': 25, 'score': 78},
    {'name': 'stu4', 'age': 19, 'score': 81},
    {'name': 'stu5', 'age': 20, 'score': 92}
]
result = max(students, key=lambda item: item['score'])
print(result)

# 案例：按照分数的高度对学生从大到小排序
result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)

# 练习1：求list1中长度最长的字符串
list1 = ['你好', 'hello', 'how are you', 'thank you! and you？', '好好学习，天天向上']
result = max(list1,key=lambda item:len(item))
print(result)
# 练习2：求nums中十位数最小的元素
nums = [92, 129, 37, 99, 150, 501]
result = min(nums,key=lambda item:item//10%10)
print(result)
# 练习3：将所有的学生按照年龄值从小到大排序
students = [
    {'name': 'stu1', 'age': 18, 'score': 90},
    {'name': 'stu2', 'age': 22, 'score': 98},
    {'name': 'stu3', 'age': 25, 'score': 78},
    {'name': 'stu4', 'age': 19, 'score': 81},
    {'name': 'stu5', 'age': 20, 'score': 92}
]
result = sorted(students,key=lambda item:item['age'])
print(result)
students.sort(key=lambda item:item['age'])
print(students)

# 练习4：求nums中各个位之和最大的元素
nums = [123, 78, 90, 201, 192, 330]
# '123'->'1'、'2'、'3'
result = max(nums, key=lambda item:sum([eval(i) for i in str(item) ]))
print(result)
# 123->eval('1+2+3)
result = max(nums,key=lambda item:eval('+'.join(str(item))))
print(result)
# 方法3
def t(item):
    sum1 = 0
    for i in str(item):
        sum1 += int(i)
    return sum1
result = max(nums, key=t)
print(result)

  2. map - 基于原序列中的元素创建一个新的序列

    1)map(函数,序列) - 通过寒素描述的规则基于序列中的元素创建一个新的序列
    函数要求：
    a.有且只有一个参数（代表后面这个序列中每个元素）
    b.有一个返回值（返回值就是新序列中的元素）
    2)map(函数,序列1,序列2)
    函数要求：
    a.有且只有2个参数（分别代表后面这两个序列中每个元素）
    b.有一个返回值（返回值就是新序列中的元素）
    3)map(函数,序列1,序列2,…)

    # 案例1：将nums中所有的元素乘以10
nums = [19, 870, 34, 61, 78]
result = map(lambda item: item*10, nums)
print(list(result))
# 案例2：获取nums中所有元素的个位数
result = map(lambda item: item%10, nums)
print(list(result))
# 案例3：将num1和num2中相同位置上的元素相乘，得到一个新序列
num1 = [10, 20, 30, 40]
num2 = [10, 20, 30, 10]
result = map(lambda i1, i2:i1*i2, num1, num2)
print(list(result))

# 练习1：获取names中每个人的姓
names = ['何晓东', '张三', '李四', '王五', '王二', '赵六']
result = map(lambda item:item[0],names)
print(list(result))
# 练习2：
students = [
    {'name': 'stu1', 'age': 18, 'score': 90},
    {'name': 'stu2', 'age': 22, 'score': 98},
    {'name': 'stu3', 'age': 25, 'score': 78},
    {'name': 'stu4', 'age': 19, 'score': 81},
    {'name': 'stu5', 'age': 20, 'score': 92}
]
subjects = ['电子信息', '金融数学', '园林设计', '经济', '计算机软件']

# ['电子信息-stu1', '金融数学-stu2',....]
result = map(lambda s1,s2:f'{s1}-{s2["name"]}',subjects,students)
print(list(result))

  3. reduce - 将序列中的元素合并成一个数据

    reduce(函数, 序列, 初始值) - 按照函数制定的规则将序列中的元素合并成一个数据
    函数的要求：
    a. 有且只有两个参数（第一个参数指向初始值，第二个参数代表序列中的每个元素）
    b. 需要一个返回值 （返回值就是合并规则）

    初始值: 累积求数值和，初始值是0
    累积求数值乘积，初始值是1
    字符串合并，初始值是空串

from  functools import reduce

nums = [12, 301, 40, 55, 112]
# 案例1：12 + 301 + 40 + 55 + 112 的结果
# 0 + 12 + 301 + 40 + ... + 112
result = reduce(lambda x, item: x + item, nums, 0)
print(result)

# 案例：12 * 301 * 40 * 55 * 112 的结果
# 1 * 12 * 301 * ... * 112
result = reduce(lambda x, item: x * item, nums, 1)
print(result)

# 案例：123014055112  -> '123014055112'
# '' + '12' + '301' + '40' + ... + '112'
# '' + str(12) + str(301) +... + str(112)
result = reduce(lambda x, item: x + str(item), nums, '')
print(result)       # '123014055112'


#练习：2+1+0+5+2
nums = [12,301,40,55,112]
result = reduce(lambda x,item:x + item%10,nums,0)
print(result)

六、迭代器

  1. 什么是迭代器(iter)

    1)迭代器是容器型数据类型(可以遍历，也可以转换成列表)，不能手动创建，无法直接提供一个迭代器，只能将其他序列转换成迭代器
    2)特点：
    a.打印迭代器的时候无法查看到元素有哪些
    b.无法通过len获取迭代器中元素的个数
    c.如果要使用迭代器中的元素必须将元素从迭代器值取走，取走的元素会从迭代器中永远消失(用一个少一个)
    3)任何数据都可以作为迭代器的元素
    应用：卡牌游戏

    # 1)创建迭代器
i1 = iter('abc')
i2 = iter([12, 34,45,56])
i3 = iter((10,1.2,'12sxcff',True,[12,35]))
# 2)打印迭代器无法查看元素
print(i1)
print(i2)
# 3)迭代器无法统计个数
# print(len(i1)) #会报错

  2. 获取迭代器中的元素

    无论以任何方式获取到了迭代器中的某个元素，那么这个元素一定会从迭代器中消失
    1)获取单个元素:
    next(迭代器) - 获取迭代器最前面的元素
    2)遍历迭代器
    for 变量 in 迭代器:
    循环体

print('------------------1.获取单个元素-------------------')
i1 = iter('abc')
i2 = iter([10, 20, 30, 40])
i3 = iter((10,1.2,'12sxcff',True,[12,35]))

print(next(i1)) #'a'
print(next(i1)) #'b'
print(next(i1)) #'c'
# print(next(i1)) #报错 StopIteration

print(next(i2)) #10
print(list(i2)) #[20, 30, 40] 以列表的方式也获取到了迭代器中的元素，此时迭代器为空了
# print(next(i2)) #报错 StopIteration


print('-------------2.遍历----------------------')
for i in i3:
    print(i)
print(list(i3))
# print(next(i3)) #报错 StopIteration
小爷爱呆桃啵啵奶茶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaScript函数进阶
流楚丶格念的博客
05-03 3242
文章目录函数进阶函数的定义方式函数声明函数表达式函数声明与函数表达式的区别函数的调用方式函数内 `this` 指向的不同场景探究案例：函数也是对象案例：函数数组的使用 函数进阶 函数的定义方式 函数声明 function foo () { } 函数表达式 var foo = function () { } 函数声明与函数表达式的区别 函数声明： 函数声明必须有名字 函数声明会函数提升，在预解析阶段就已创建，声明前后都可以调用 函数表达式： 函数表达式类似于变量赋值 函数表达式可以没有名字，例如
带你学习javascript的函数进阶（二）
01-08
总之，JavaScript的函数进阶涵盖了多种强大的概念，如严格模式、高阶函数、闭包和递归，这些都极大地丰富了我们的编程工具箱，帮助我们编写更加健壮、可维护的代码。通过深入学习和实践这些概念，开发者可以提高代码...
Python:函数进阶
weixin_62735525的博客
12-06 821
五分钟学会函数的进阶
Excel 函数进阶
qq_44802667的博客
07-16 935
文章目录Excel 函数进阶清洗类函数时间类函数逻辑类函数关联匹配函数计算统计类函数 Excel 函数进阶 清洗类函数 left()函数是一个字符串函数，它返回具有指定长度的字符串的左边部分。使用：=Left(文本单元格, 字符串长度)， 计算从左边算起。 right()函数是一个字符串函数，它返回具有指定长度的字符串的右边部分。使用：=Right(文本单元格, 字符串长度)， 计算从右边算起。 mid()函数从指定位置开始，提取用户指定的字符数。使用：=MID(文本单元格，开始位置，字符串长度)。 le
Python函数进阶
YuanXiaoHei88的博客
08-02 353
python函数进阶
函数进阶
2401_83846985的博客
05-09 870
使⽤*args和**kwargs来调⽤函数。
js函数进阶
weixin_45802907的博客
09-26 100
函数进阶 一、递归函数 在函数内调用函数本身的函数就是递归函数 递归函数必须要给内部函数本身调用的语句加限制 function x() { x(); } 二、回调函数 一个函数作为参数传递给另一个函数,那么这个函数就叫回调函数 jquery事件函数就是回到函数 常用的回调函数 setInterval setTimeout requestAnimationFram jquery动画回调 三、匿名函数 没有命名的函数 一般来说匿名函数都是当作参数 匿名函数不能直接创建,一般是创建的时候立即执
python函数进阶篇笔记
2301_81135589的博客
05-13 417
（3）缺省参数：也叫默认参数，用于定义函数，为参数提供默认值，调用函数时不可传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数的定义和调用）注：参数是“键=值”的形式的情况下，所有的“键=值”都会被kwargs接收，同时会根据“键=值”组成字典。注：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。（4）不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。（1）位置参数：调用函数时根据函数定义的参数位置来传递参数。
第七章 Python函数进阶
weixin_64953311的博客
04-19 493
按照返回值的顺序，写对应顺序的多个变量接受即可变量之间用逗号隔开支持不同类型的数据return。
Python入门学习(八)---函数进阶
weixin_47109902的博客
09-17 216
Python入门学习(八)---函数进阶
php函数讲解,php函数进阶讲解
weixin_42584586的博客
03-10 138
使用变量储存函数名，调用的时候写成变量()的形式。 本文主要和大家分享php函数进阶讲解，希望能帮助到大家。适用情况：根据用户反馈信息类型，调用不同的函数时使用。实例：$funf = 'test';$funf();函数内部调用函数外部变量使用use关键字实例function test(){$msg = "I'm message.";// 使用use关键字，获取变量$say = function($...
计算机语言python函数进阶
05-09
Python函数进阶 多参数解析 使⽤ `*args`（元组） 和 `**kwargs` （字典）来调⽤函数 使用`*args`非关键字可变参数方式 # 以元祖方式传递 nums = (1, 2, 3) 使用`**kwargs`关键字可变参数方式 # 以字典...
14.DAX函数进阶篇（2）共14页.pdf.zip
11-20
【标题】"14.DAX函数进阶篇（2）共14页.pdf.zip" 提供的是一份关于DAX函数高级使用的教程资料，共有14页内容。DAX（Data Analysis Expressions）是Power BI、Power Pivot以及Excel中的一个强大公式语言，用于数据...
13.DAX函数进阶篇（1）共8页.pdf.zip
11-19
【标题】"13.DAX函数进阶篇（1）共8页.pdf.zip" 提供的信息表明，这是一个关于DAX函数高级使用的教学资料，共有8页内容，被压缩成一个ZIP文件。DAX（Data Analysis Expressions）是Power BI、Power Pivot等Microsoft...
Python基础 5 - 类、对象、注解
云端梦留白的博客
09-04 831
面向对象（Object-Oriented, OOP）是一种编程范式，它使用“对象”来设计软件，这些对象包含数据（通常称为属性或字段）和代码（通常称为方法或函数），以模拟现实世界实体的属性和行为。面向对象是一种编程方法，通过创建包含数据和行为的对象来模拟现实世界，提高代码的组织性、重用性和灵活性。在 Pyhon 中，想要使用类，必须先创建对象。class 类名称 : # class 关键字，表示定义了一个类，类首字符大写为标准。
JS都有哪些操作数组的方法
最新发布
ggq53219的博客
09-04 331
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。
CSS解析:定位和层叠上下文
晓风残月淡的博客
08-31 2050
许多开发人员对定位的理解很粗略，如果不完全了解定位，就很容易给自己挖坑。有时候可能会把错误的元素放在其他元素前面，要解决这个问题却没有那么简单。一般的布局方法是用各种操作来控制文档流的行为。定位则不同：它将元素彻底从文档流中移走。它允许你将元素放在屏幕的任意位置。还可以将一个元素放在另一个元素的前面或后面，彼此重叠。
asyncio note
weixin_48232453的博客
09-03 742
python异步库asyncio入门
C语言教程：函数进阶与日期运算解析
"C程序设计快速进阶大学教程——第14章 函数进阶，主要探讨了函数的分解与抽象以及递归的概念，并通过日期运算的实例详细讲解了这两个主题。" 在C程序设计中，函数是组织代码的重要方式，它们能够帮助我们将复杂的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值