day12 函数的进阶+今日作业

洋洋酒仙

已于 2022-08-03 19:11:30 修改

阅读量158

点赞数

文章标签： python 开发语言

于 2022-08-02 20:57:52 首次发布

本文链接：https://blog.csdn.net/qq_59778168/article/details/126130290

版权

4.4函数的返回值

1.函数的返回值

1）什么是返回值 - 返回就是从函数内部传递到函数外部的数据（python中的每个函数都可以传递一个数据到函数外部）

2）如何将函数内部的数据传递到外部 - return后面的值就是函数的返回值（执行函数体时如果遇到return，那么return后面的值就是

函数的返回值）

3）怎么在函数外部获取函数返回值 - 获取函数调用表达式的值就是获取该函数的返回值

函数调用表达式 - 调用函数的语句

4)什么时候使用返回值：如果实现函数的功能，产生了新的数据作为函数的返回值返回

1）return确定返回值

# return后面放需要返回的数据
def func1(a,b):
    return a+b
print(func1(10, 20))
# 一个函数只有一个返回值(一个函数最多只能有一个return有效)，如果想要把多个数据作为函数值返回，可以在一个return后面写多个数据
def func2(a,b):
    result1=a+b
    result2=a*b
    return (result1,result2)

# return除了可以返回数据，还会提前结束函数（执行函数体的时候如果遇到return，函数结束）
def func3():
    print('+++++')
    print('-----')
    return       #相当于return None   什么时候遇到return什么时候结束
    print('=====')


print(func3())

2）获取函数返回值

函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数表达式都可以做

4.5 变量作用域

1.变量作用域 - 变量在定义完成后可以使用的范围

根据变量作用域的不同分为：全局变量和局部变量

2.全局变量和局部变量

1）全局变量

没有定义在函数里面或者类里面都是全局变量

作用域：从定义开始，到程序结束（程序结束前的任何位置都可以使用）

# a是全局变量
# 案例1：
a = 10
# 案例2:
# i,b都是全局变量
for i in range(5):
    b=10

2）局部变量

定义在函数中的变量就是局部变量（定义在类中的是属性）

作用域：从定义开始到函数结束

def func1(c):
    d=30
    print(f'{c}{d}')
func1(40)
# print(f'{c}{d}')   报错！！！

3.不同变量的存储方式

全局变量默认保存在全局栈区间（程序结束的时候才被释放），

局部变量默认是保存在函数对应的临时栈区间中（函数对应的临时栈区间，创建函数的时候会被创建出来，函数调用结束会被自动释放）

在函数中定义变量的时候可以在定义变量前加global关键字，让函数中定义的变量可以保存在全局栈区间中

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

x=100 #保存全局栈区间
i=10
def func4():
    x=10 #重新创建一个局部变量x，保存在func4对应的临时栈区间
    y=200 #保存在func4对应的临时栈区间
    global z #global为了将z保存在全局栈区间
    z=300 #保存在全局栈区间
    global i
    i=1000
    print(x,y,z)
func4()
print(f'{x}{z}{i}')

4.函数参数的确定

（1）调用函数的时候，实参到底应该给什么数据，有什么决定？
由参数在函数体中的使用方式决定

（2）实参高阶函数 - 函数的参数是函数
如果一个参数是函数，传参的时候有两种方法：1）用普通函数的函数名 2）使用匿名函数

def func1(x):
    print(x)
func1(10)

def func2(x):
    x()
def tem():
    print('临时')
func2(tem)

# x必须是函数，有一个参数，返回值必须是数字
def func3(x): #func3是实参高阶函数
    print(x(10)+20)

def tem2(m):
    return 19

func3(tem2)

# 小练习（以前的知识）
# num  ->  xx:xx
num=90
print('{:0>2}:{:>2}'.format(num//60,num % 60))
num=[90]
for i in num:
    print('{:0>2}:{:>2}'.format(i//60,i % 60))
def time(num):
    return '{:0>2}:{:>2}'.format(i // 60, i % 60)
num=90
print(time(num))

4.6 匿名函数

1.匿名函数
匿名函数的本质还是函数但是它只能实现功能简单的函数（一行语句就能实现它的功能）

语法：
函数名 = lambda 形参列表:返回值

相当于：
def 函数名（形参列表）:
return 返回值

# 定义一个函数求两个数的和
sum1 = lambda a,b : a+b
print(sum1(10,20)) #30
print(sum1(a=100,b=200)) #300

2.匿名函数的应用
在给实参高阶函数传参的时候可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就用匿名函数，不行才用普通函数)

def func1(x):
    print(x(10,20)+10)


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


func1(temp1)


func1(lambda m,n:12)

4.7 常用高阶函数

1.max、min、sorted

max(序列) - 直接比较序列中元素发的大小，求出最大值

max(序列，key=函数) - 按照函数制定的比较规则比较元素的大小，求出最大值

函数的要求：a.有且只有一个参数（代表序列中的每个元素）；

b.需要一个返回值（返回值是比较对象 - 将参数看出元素，在这个地方来描述比较对象和元素之间的关系）

# 示例1：求nums的最大值
nums=[21,32,323,34,3,45]
result = max(nums,key=lambda item:item) #item是本来的元素,比较对象和元素的关系
print(result)
# 示例2：
nums=[21,32,323,34,3,45]
result1 = max(nums,key=lambda item:item % 10) #比较对象和元素的关系
print(result1)
# 示例3：
# result2 = max(students,key=lambda item:item['age'])
# print(result2)


# 练习1：求nums中十位数最大的元素:  90
nums = [9108, 23, 167, 90, 556, 149]
result1 = max(nums,key=lambda item:item//10 %10) #返回值是比较对象
print(result1) #90
# 练习2：求nums中绝对值最小的元素
# 方法一：
nums = [-992, 12, 78, -34, 99]
result2 =min(nums,key=lambda item:(-item if item<0 else item))
print(result2) #12
# 方法二：
# abs()函数返回x（数字）的绝对值
nums = [-992, 12, 78, -34, 99]
result2 =min(nums,key=lambda item:abs(item))
print(result2) #12
# 方法三：
result2 =min(nums,key=lambda item:item**2)
print(result2) #12
# 练习3：nums中各个位数之和最大的元素
nums = [102, 19, 48, 221, 52]
# 3,10,12,5,7  ->  48
result3 =max(nums,key=lambda item:item%10+item//10%10+item//100)
print(result3) #48
# 方法一：
result3 =max(nums,key=lambda item:sum([int(i) for i in str(item)]))
print(result3)
# # 方法二：
# nums = [102, 19, 48, 221, 52]
# def temp(item):
#     sum1=0
#     for x in str(item):
#         sum1+=int(x)
#     return sum1
# result3 =max(nums,key=lambda item:temp)
# print(result3)
# 练习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': '男'}
]
result4 =sorted(students,key=lambda item:item['score'],reverse=True)
print(result4)
# 方法二：
students.sort(key=lambda item:item['score'])
print(students)

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

map(函数,*序列) - 根据函数制定的规则将指定序列中的元素转换成新序列中的元素

函数的要求：a.参数有且只有（有几个序列就有几个参数）参数）

b.有返回值（返回值对应的就是新序列的元素）

# 示例1：创建一个列表，列表中的元素是nums中所有元素的个位数
nums=[12,213,32,34,21,12,3,21,23]
result = map(lambda item: item % 10, nums) #建议先写序列，知道需要传参几个
print(list(result))
# 示例2：将A和B中的元素对应求和产生一个新的列表
A=[3000,5600,9800,4200,10000]
B=[1500,1000,2200,1300,3200]
result = map(lambda item1,item2:item1+item2 , A,B)
print(list(result))


# 练习1：将nums中所有的元素乘以10
nums = [82, 67, 89, 6617, 90, 23, 71]
result = map(lambda item:item*10,nums)
print(list(result))
# 练习2：基于scores创建一个列表，列表中元素根据nums中元素确定为'及格'或者'不及格'
scores = [82, 67, 89, 66, 90, 23, 71]
# ['及格', '及格', '及格', '及格', '不及格', '及格']
result1 = map(lambda item:'及格'if item>=60 else '不及格',nums)
print(list(result1))
# 练习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}, .....]
student = map(lambda item1,item2,item3:{'name':item1,'age':item2,'score':item3},names,ages,scores)
print(list(student))

3.reduce - 将序列中的元素通过指定的规则合并成一个数据

reduce(函数,序列,默认值)

函数的要求：a.有且只有两个参数（第一个参数指向默认值，第二个参数指向序列中的每个元素）

b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中的元素进行什么样的操作得到的）

# reduce使用之前需要先导入
from functools import reduce
# 示例1：求nums中所有元素的和
nums=[10,23,43,43,435,65]
result = reduce(lambda i,item:i+item,nums,0)
print(result) #619
# 示例2：求nums中所有元素的乘积
nums=[10,23,43,43,435,65]
result = reduce(lambda i,item:i*item,nums,1)
print(result) #12024509250
# 示例3：求所有元素个位数上的和
nums=[10,23,43,43,435,65]
result = reduce(lambda i,item:i+item%10,nums,0)
print(result) #19
# 示例4：将所有的元素合并成字符串
nums=[10,23,43,43,435,65]
result = reduce(lambda i,item:i+str(item),nums,'')
print(result) #1023434343565
# 示例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,0)
print(result) #427

今日作业

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

leap_year = lambda year:'闰年' if year % 4 == 0 and year % 100 != 0 or year % 400 ==0 else '平年'
print(leap_year(2000))

写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)
```
list1=[1,2,3]
reverse_list = sorted(list1,key=lambda item:item,reverse=True)
print(reverse_list)
```
编写一个函数，计算一个整数的各位数的平方和

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

from functools import reduce
num=str(12)
int_square = reduce(lambda i,item:i+int(item)**2,num,0)
print(int_square)

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

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

nums = [-23, 100, 89, -56, -234, 123]
min_value = min(nums,key=lambda item:abs(item))
print(min_value)

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

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

dict1 = map(lambda key,value: [key,value],A,B)
print(dict(dict1))

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

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

num = map(lambda i,j:j+i,nums,subjects)
result = map(lambda m,n:[m,n],names,list(num))
print(dict(result))

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

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

message = ['你好', 20, '30', 5, 6.89, 'hello']
sum1 = reduce(lambda i,item:i+(item if type(item)==int or type(item)==float else 0),message,0)
print(sum1)

已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）
```
points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]
```
1）获取列表中y坐标最大的点
```
max_z = max(points,key=lambda i:i[-1])
print(max_z)
```
2）获取列表中x坐标最小的点
```
min_z = min(points,key=lambda i:i[0])
print(min_z)
```
3）获取列表中距离原点最远的点
```
farthest = max(points,key=lambda i:i[0]**2 +i[-1]**2)
print(farthest)
```
4）将点按照点到x轴的距离大小从大到小排序

sort_distance = sorted(points,key=lambda i:abs(i[-1]))
print(sort_distance)

洋洋酒仙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day12 函数的进阶+今日作业

函数的进阶
复制链接

扫一扫