函数（递归，匿名函数lambda，列表排序，列表推导式）和文件读写操作与集合

一、函数

1、两种输出的小数位控制

# num = 10
#
#
# def anum():
#     num = 20
#     print(num)
#
#
# anum()
num = 3.14

print("%.3f" % num)
# f"{变量:.nf}"
print(f"{num:.3f}")  # 3.140
num1 = 1  # 00000001
print('%6d' % num1)
print('%06d' % num1)  # 000001
print(f'{num1:06d}')  # 000001

2、递归

（1）求和

递归函数的形成条件:

1. 函数自己调用自己

2. 函数必须有一个终止条件

def get_age(num):
    """
    求第 num 个人的年龄,每相邻的两个人的年龄差两岁, 已知第一个人的年龄是 18岁
    :param num:
    :return:
    """
    if num == 1:
        return 18
    # 求第 num个人的年龄,只需要num-1 这个人的年龄 + 2
    age = get_age(num-1) + 2
    return age


print(get_age(4))

 （2）阶乘

def func(n):
    num = 1
    for i in range(1, n + 1):
        num = num * i

    print(num)


def func2(n):
    if n == 1:
        return 1
    # 想要求 n! , 只需要(n-1)! * n
    num = func2(n-1) * n
    return num


# func(5)
print(func2(5))

（3）求1到100的和

def func(num):
    if num == 1:
        return 1
    sum = func(num-1) + num
    return sum

a = func(100)
print(a)

3、匿名函数

使用 lambda 关键字定义的函数就是匿名函数

lambda 参数列表：表达式

1、无参数无返回值

def 函数名()：
  函数代码

lambda:函数代码

2、无参数有返回值

def 函数名()：
    return 1 + 2

lambda: 1 + 2

3、有参数无返回值

def 函数名(a, b):
  print(a, b)
  
  
lambda a, b: print(a, b)

4、有参数有返回值

def 函数名(a, b):
  return a + b

lambda a, b: a + b

# 1、无参无返回值
from typing import Any, Callable


def func1():
    print('hello')


(lambda: print('hello lambda'))()  # 如果，没有后面的括号就无法执行输出
func1()


# 2、无参有返回值
def func2():
    return 1 + 2


f = lambda: 1 + 2
print(f)  # <function <lambda> at 0x000002264E25B9D0>
print(f())  # 3


# 3、有参无返回值
def func3(name):
    print(name)


f1 = lambda name: print(name)
f1('hello')
# 4、有参有返回值
def func4(*args):
    return args


f4 = lambda *args: args
print(f4(1, 2, 3, 4, 5))

 使用

def my_calc(a, b, func):
    """
    进行四则运算
    :param a: 第一个数据
    :param b: 第二个数据
    :param func: 函数,要进行的运算
    :return: 运算的结果
    """
    print('其他的函数代码...')
    num = func(a, b)
    print(num)


def add(a, b):
    return a + b


# 调用
my_calc(10, 20, add)
my_calc(10, 20, lambda a, b: a - b)  # return 的值不同罢了
my_calc(10, 20, lambda a, b: a * b)
my_calc(10, 20, lambda a, b: a / b)

4、列表排序

列表排序, 列表中的数据的类型要保持一致

匿名函数的形参（即第一个x，写早冒号前面的）是列表中的每一个数据

 形参: (排序规则1, 排序规则2, ...))
# 当第一个规则相同,会按照第二个规则排序

# 列表排序, 列表中的数据的类型要保持一致
my_list = [1, 3, 5, 4, 2, 1]
my_list.sort()
print(my_list)  # [1, 1, 2, 3, 4, 5]

list1 = [{'name': 'd', 'age': 19},
         {'name': 'b', 'age': 16},
         {'name': 'a', 'age': 16},
         {'name': 'c', 'age': 20}]

# list1.sort()  # 程序报错
# 匿名函数的形参（即第一个x，写早冒号前面的）是列表中的每一个数据
list1.sort(key=lambda x: x['name'])
print(list1)
# [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'c', 'age': 20}, {'name': 'd', 'age': 19}]
list1.sort(key=lambda x: x['age'])
print(list1)
# [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'd', 'age': 19}, {'name': 'c', 'age': 20}]

list2 = ['aghdd', 'bc', 'ghlj', 'def', 'ab']
list2.sort()
# print(list2)
# 需求: 根据列表中字符串的长度,列表进行排序
list2.sort(key=len)
list2.sort(key=lambda x: len(x))  # 两种方式均可以
print(list2)  # ['ab', 'bc', 'def', 'ghlj', 'aghdd']

# sort(key= lambda 形参: (排序规则1, 排序规则2, ...))
# 当第一个规则相同,会按照第二个规则排序

list1.sort(key=lambda x: (x['age'], x['name']))
print(list1)
# [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'd', 'age': 19}, {'name': 'c', 'age': 20}]
list1.sort(key=lambda x: (x['age'], x['name']), reverse=True)
print(list1)
# [{'name': 'c', 'age': 20}, {'name': 'd', 'age': 19}, {'name': 'b', 'age': 16}, {'name': 'a', 'age': 16}]

5、列表推导式

# 列表推导式，为了快速的生成一个列表
# 1、变量 = [生成数据的规则  for 临时变量 in xxx]
# 每循环一次，就会创建一个数据

# 2. 变量 = [生成数据的规则 for 临时变量 in xxx if xxx]
# 每循环一次,并且if条件为True,生成一个数据

# 3. 变量 = [生成数据的规则 for 临时变量 in xxx  for j in xxx]
# 第二个for 循环 循环一次,生成一个数据

# 补充: 字典推导式
# 变量 = {生成字典的规则 for 临时变量 in xx}

'''因为字典的key值没有发生变化，只是value值在变，所以取最终值'''

# 列表推导式，为了快速的生成一个列表
# 1、变量 = [生成数据的规则  for 临时变量 in xxx]
# 每循环一次，就会创建一个数据
my_list = [i for i in range(5)]
print(my_list )  # [0, 1, 2, 3, 4]

my_list1 = ['hello' for i in range(5)]
print(my_list1)  # ['hello', 'hello', 'hello', 'hello', 'hello']

my_list2 = [f'num:{i}' for i in my_list ]
print(my_list2 )  # ['num:0', 'num:1', 'num:2', 'num:3', 'num:4']
my_list3 = [i+1 for i in range(5)]
print(my_list3 ) # [1, 2, 3, 4, 5]

# 2. 变量 = [生成数据的规则 for 临时变量 in xxx if xxx]
# 每循环一次,并且if条件为True,生成一个数据
my_list = [i for i in range(5) if i % 2 == 0]
print(my_list)  # [0, 2, 4]

# 3. 变量 = [生成数据的规则 for 临时变量 in xxx  for j in xxx]
# 第二个for 循环 循环一次,生成一个数据
my_list4 = [(i,j) for i in range(3) for j in range(3)]
print(my_list4)  # [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]



# 补充: 字典推导式
# 变量 = {生成字典的规则 for 临时变量 in xx}
# my_dict = {key: value for i in range(3)}
my_dict = {f"name{i}": i for i in range(3)}
print(my_dict)  # {'name0': 2, 'name1': 2, 'name2': 2}

my_dict = {f"name{i}": j for i in range(3) for j in range(3)}
print(my_dict)  # 3个数据  {'name0': 2, 'name1': 2, 'name2': 2}
'''因为字典的key值没有发生变化，只是value值在变，所以取最终值'''
my_dict = {f"name{i}{j}": j for i in range(3) for j in range(3)}
print(my_dict)
# {'name00': 0, 'name01': 1, 'name02': 2, 'name10': 0, 'name11': 1, 'name12': 2, 'name20': 0, 'name21': 1, 'name22': 2}

二、集合

# 集合 set 定义使用 {}  , {数据, 数据}
# 1. 集合中的数据必须是不可变类型

# 2. 集合是可变类型

# 修改数据 100 ---> 200  先删除，再添加新数据

# 3. 集合是无序的,(数据的添加顺序和输出顺序是否一致), 不支持下标操作
# 4. 集合中的数据没有重复数据(去重)

# 集合, 列表, 元组 三者之间可以互相转换

# 集合 set 定义使用 {}  , {数据, 数据}
# 1. 集合中的数据必须是不可变类型
my_set = {1, 3.14, False, 'hello', (1, 2)}
print(my_set, type(my_set))
# my_set = {[1, 2]}   # 代码报错
# 2. 集合是可变类型
my_set.remove(3.14)
print(my_set)
my_set.pop()
print(my_set)
print('----')
my_set.add(100)
print(my_set)
# 修改数据 100 ---> 200  先删除，再添加新数据
my_set.remove(100)
my_set.add(200)
print(my_set)
my_set.clear()
print(my_set)   #
# 3. 集合是无序的,(数据的添加顺序和输出顺序是否一致), 不支持下标操作
# 4. 集合中的数据没有重复数据(去重)
my_list = [1, 2, 3, 4, 2, 5, 1, 0]
my_list = list(set(my_list))
print(my_list)
# 集合, 列表, 元组 三者之间可以互相转换

三、文件

1、只读文件

# 1. 打开文件, 是文件从硬盘中存到内存中
# open(file, mode='r',  encoding)
# file 要操作的文件名字, 类型是 str
# mode, 文件打开的方式, r(read) 只读打开, w(write) 只写打开  a(append) 追加打开
# encoding  文件的编码格式, 常见的编码格式有两种, 一种是gbk, 一种是utf-8
# 返回值, 文件对象, 后续所有的文件操作,都需要通过这个文件对象进行

# 以只读的方式打开当前目录中,1.txt 文件, 文件不存在会报错
f = open('1.txt', 'r')
# 2. 读文件 文件对象.read()
buf = f.read()
print(buf)
# 3. 关闭文件  文件.close()  将内存当中的文件同步到硬盘中
f.close()

2、文件的写操作

# 1. 打开文件 w 方式打开文件,文件不存在,会创建文件, 文件存在,会覆盖清空原文件

# 1. 打开文件 w 方式打开文件,文件不存在,会创建文件, 文件存在,会覆盖清空原文件
f = open('a.txt', 'w', encoding='utf-8')
# 2. 写文件 文件对象.write(写入文件的内容)
f.write('hello world!\n')
f.write('hello python!\n')
f.write('你好,中国!')
# 3. 关闭文件
f.close()

3、文件的‘a’操作

可以重复添加数据，不会覆盖之前的数据，是追加数据的

# a 方式打开文件, 追加内容,在文件的末尾写入内容
# 文件不存在,会创建文件 ，创建在本目录下
# 注意点: 不管是a 方式打开文件,还是 w 方式打开文件,写内容,都是使用 write()函数

f = open('b.txt', 'a', encoding='utf-8')
# f.write('hello world!\n')
f.write('111\n')
f.close()