递归、lambda 匿名函数、内置函数 format、zip函数将两个列表参数拼接成一个字典、open函数和with open 函数区别

搞IT的放牛娃

已于 2023-06-19 16:06:57 修改

阅读量279

点赞数

文章标签： python 开发语言

于 2022-10-20 15:21:34 首次发布

本文链接：https://blog.csdn.net/weixin_64672480/article/details/127427542

版权

递归

# 需求：3以内数字累加和 3 + 2 + 1 = 6
# 6 = 3 + 2以内数字累加和
# 2以内数字累加和 = 2 + 1以内数字累加和
# 1以内数字累加和 = 1  # 出口

# 递归特点：函数内部自己调用自己；必须有出口
def sum_numbers(num):
    # 2. 出口
    if num == 1:
        return 1
    # 1. 当前数字 + 当前数字-1的累加和
    return num + sum_numbers(num-1)

result = sum_numbers(3)
print(result)

# 如果没有出口，报错：超出最大递归深度

lambda 匿名函数

# 1. 无参数
fn1 = lambda: 100
print(fn1())


# 2. 一个参数
fn2 = lambda a: a
print(fn2('hello world'))


# 3. 默认参数/缺省参数
fn3 = lambda a, b, c=100: a + b + c
print(fn3(10, 20))
print(fn3(10, 20, 200))


# 4. 可变参数：*args
fn4 = lambda *args: args
print(fn4(10, 20))
print(fn4(10, 20, 30, 40))
print(fn4(10))


# 5. 可变参数：**kwargs
fn5 = lambda **kwargs: kwargs
print(fn5(name='Python'))
print(fn5(name='Python', age=30))

# 定义函数简化语法，不写def，也不用写return，一行代码就能定义一个函数

def my_sum1(a,b):             # 定义一个函数my_aum1,设置形式参数a和b
    return a + b              # 给函数my_aum1返回a + b得值

print(my_sum1(2,5))           # 调用函数 打印结果为：7


# 以上函数等同于以下lambsa函数表达式
my_sum2 = lambda a,b : a + b

# print(my_sum2(2,5))           # 打印结果为：7

def my_max1(a,b):            # 函数体内的if判断语句写法
    if a > b:
        return a
    else:
        return b

print(my_max1(4,5))          # 打印结果为：5


# lambda匿名函数的 if语句写法
my_max2 = (lambda a,b : a if a > b else b)

print(my_max2(4,5))          # 打印结果为：5

my_max2 = (lambda a,b : a if a > b else b)(4,5)

print(my_max2)               # 打印结果为：5

注意：
# 匿名函数内部只能有一条语句，而且这条语句要有具体的值返回匿名函数内部不能使用print

lambda 的缺省（默认值）参数

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}
]

# sort(key=lambda..., reverse=bool数据)
# 1. name key对应的值进行升序排序
students.sort(key=lambda x: x['name'])
print(students)

# 2. name key对应的值进行降序排序
students.sort(key=lambda x: x['name'], reverse=True)
print(students)

# 3. age key对应的值进行升序排序
students.sort(key=lambda x: x['age'])
print(students)

abs() 和 round() 函数

# abs(): 绝对值
print(abs(-10))

# round()： 四舍五入
print(round(1.2))
print(round(1.9))

# 需求：任意两个数字，先进行数字处理(绝对值或四舍五入)再求和计算

# 1. 写法一
# def add_num(a, b):
#     # 绝对值
#     return abs(a) + abs(b)

# result = add_num(-1.1, 1.9)
# print(result)


# 2. 写法二：高阶函数:f是第三个参数，用来接收将来传入的函数
def sum_num(a, b, f):
    return f(a) + f(b)

result1 = sum_num(-1, 5, abs)
print(result1)

result2 = sum_num(1.1, 1.3, round)
print(result2)

高阶函数：一个函数作为另一个函数的参数

map 高阶函数

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

# 1. 准备列表数据
list1 = [1, 2, 3, 4, 5]

# 2. 准备2次方计算的函数
def func(x):
    return x ** 2

# 3. 调用map
result = map(func, list1)

# 4. 验收成果
print(result)         # 地址值
print(list(result))   # [1, 4, 9, 16, 25]

reduce 高阶函数
作用：功能函数计算的结果和序列的下一个数据做累计计算

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

list1 = [1, 2, 3, 4, 5]

# 1. 导入模块
import functools

# 2. 定义功能函数
def func(a, b):
    return a + b

# 3. 调用reduce，作用：功能函数计算的结果和序列的下一个数据做累计计算
result = functools.reduce(func, list1)
print(result)      # 15

filter 高阶函数

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

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 1. 定义功能函数：过滤序列中的偶数
def func(x):
    return x % 2 == 0

# 2. 调用filter
result = filter(func, list1)
print(result)

print(list(result))     # [2, 4, 6, 8, 10]

format 内置函数

format() 是一种格式化字符串的函数，该函数增强了字符串格式化的功能。
基本语法:是通过{} 和 : 来代替以前的%
format 函数按索引位{}输出，位置可以不按顺序

1、不设置指定位置，按默认顺序

yy ="{} {}".format("hello","world",'nihao')
print(yy)

2、索引位输出字符串

yy ="{1} {0} {0}".format("hello","world",'ninhao')
print(yy)

3、参数名称进行格式化输出

yy ="{name} {age}".format(name='小王',age='18')
print(yy)

4、格式化输出列表

list1 = ['xiaowang','18']
str1 = '姓名:{0[0]} 年龄:{0[1]}'.format(list1)
print(str1)

list1 = ['xiaowang','18']
list2 = ['china']

str1 = '姓名:{0[0]} 年龄:{1[0]}'.format(list1,list2)
print(str1)

5、格式化输出字典

dict1 = {'name':'xiaowang','age':18}
str1 = '姓名:{name} 年龄{age}'.format(**dict1)
print(str1)

内置函数 zip() 可以将两个列表参数拼接成一个字典

1)、zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。

2)、如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象 相同，利用 * 号操作符，可以将元组解压为列表。

普通方法：两个列表变成一个字典

list1 = [1,2,3]
list2 = ['li','he','zi']
a = len(list1)

dict1 = {}

for i in range(a):
    dict1.setdefault(list1[i],list2[i])

print(dict1)

Zip方法：两个列表变成一个字典

list1 = ['name','age','url']
list2 = ['xiaowang',18,'wwww.duoceshi.cn']

list3 = list(zip(list1,list2))
list4 = dict(list3)
print(list4)

内置函数之 open

# 用于打开一个文件，创建一个file文件对象，相关的方法才可以调用它进行读写
# 语法:Open(file, mode)     file：文件的绝对路径     mode： 权限/模式

# 模式有r(只读),w(读写),a(写入模式,追加)

读取模式 read

例如：新建文本文档.txt    (文档内容如下)
456 DCS真牛逼

DCS真牛逼


a = open(r'D:\pycharm\dcs\lesson\新建文本文档.txt','r',encoding="utf-8")  
# encoding="utf-8"           # 解决中文输出不报错

all = a.read()               # 显示出文件的所有内容 显示的数据类型为字符串
all = a.readlines()          # 显示出文件中的所有内容 显示的数据类型为列表
all = a.readline()           # 显示文件中的第一行内容 显示的数据类型为字符串
                             # 第二次调用readline() 显示第二行，第三次调用，显示第三行
print(all)
print(type(all))

写的模式 write

a = open(r'D:\pycharm\dcs\lesson\新建文本文档.txt','w',encoding="utf-8")
a.write('123333')      # write 函数里面的值不能是整形  w 原有的文件内容会被覆盖
a.writelines('456')    # w 原有的文件内容会被覆盖
a.close()              # 写完之后关闭文件

追加模式 源文件内容不会被覆盖

a = open(r'D:\pycharm\dcs\lesson\新建文本文档.txt','a',encoding="utf-8")
a.write('\nDCS真牛逼\n')
a.close()              # 写完之后关闭文件

# r+:  r没有该文件则报错; 文件指针在开头，所以能读取出来数据
# f = open('test1.txt', 'r+')
# f = open('test.txt', 'r+')

# w+: 没有该文件会新建文件；w特点：文件指针在开头，用新内容覆盖原内容
# f = open('test1.txt', 'w+')
# f = open('test.txt', 'w+')

# a+:没有该文件会新建文件；文件指针在结尾，无法读取数据(文件指针后面没有数据)
f = open('test4.txt', 'a+')

con = f.read()
print(con)

f.close()

seek 函数

语法： 文件对象.seek(偏移量, 起始位置)  0开头1当前2结尾
目标：
    1. r 改变文件指针位置：改变读取数据开始位置或把文件指针放结尾(无法读取数据)
    2. a 改变文件指针位置，做到可以读取出来数据

f = open('test.txt', 'a+')

# 1. 改变读取数据开始位置
# f.seek(2, 0)

# 2. 把文件指针放结尾(无法读取数据)
# f.seek(0, 2)

# 3. a 改变文件指针位置，做到可以读取出来数据
# f.seek(0, 0)
f.seek(0)

con = f.read()
print(con)

f.close()

文件备份

# 1. 用户输入目标文件  sound.txt.mp3
old_name = input('请输入您要备份的文件名：')
# print(old_name)
# print(type(old_name))

# 2. 规划备份文件的名字
# 2.1 提取后缀 -- 找到名字中的点 -- 名字和后缀分离--最右侧的点才是后缀的点 -- 字符串查找某个子串rfind
index = old_name.rfind('.')
# print(index)

# 4. 思考：有效文件才备份 .txt
if index > 0:
    # 提取后缀
    postfix = old_name[index:]

# 2.2 组织新名字 = 原名字 + [备份] + 后缀
# 原名字就是字符串中的一部分子串 -- 切片[开始:结束:步长]
# print(old_name[:index])
# print(old_name[index:])
# new_name = old_name[:index] + '[备份]' + old_name[index:]
new_name = old_name[:index] + '[备份]' + postfix
print(new_name)

# 3. 备份文件写入数据(数据和原文件一样)
# 3.1 打开 原文件 和 备份文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')

# 3.2 原文件读取，备份文件写入
# 如果不确定目标文件大小，循环读取写入，当读取出来的数据没有了终止循环
while True:
    con = old_f.read(1024)
    if len(con) == 0:
        # 表示读取完成了
        break

    new_f.write(con)

# 3.3 关闭文件
old_f.close()
new_f.close()

with open 和 open的区别？
Open函数，文件读写时出错，就无法关闭文件，因此会占用系统资源

with open会创建一个临时的运行环境，自动调用close方法，无论是安全退出还是遇到什么问题都会关闭文件。
with 这个关键字的作用：With用于创建一个临时的运行环境，运行代码执行完成之后会退出环境

with open 函数使用

with open(r'D:\pycharm\dcs\lesson\新建文本文档.txt','r',encoding="utf-8") as file:
   all = file.read()
   all = file.readline()
   all = file.readlines()
   print(all)