01-recode

1.递归函数（了解）(消耗cpu)

a.找临界值
b.找关系（f(n)和f(n-1)）
c.用f(n-1)实现f(n)

能用循环就不使用递归，因为递归性能低（消耗大量内存和cpu资源）

2.模块

模块就是py文件

import 模块
from 模块  import 内容

import 模块 as ..
from 模块 import 内容 as ...

3.迭代器和生成器

iter - 将其他序列转换成迭代器；生成器
元素 - next（），for - in

生成器：调用带有一个yield关键字的函数

02-generative

1.什么是生成式

生成式就是生成器的一种特殊写法

2.写法

a.
生成器 = (表达式 for 变量 in 序列 )  -->让变量去序列中取值，每取一个值
就将对应的表达式的值作为生成器的元素

def 函数名（）：
    for 变量 in 序列：
    yield 表达式

b.
生成器 = （表达式 for 变量 in 序列 if 条件语句）

def 函数名（）：
    for 变量 in 序列：
         if 条件语句：
             yield  表达式

gen1 = (x * 2 for x in range(5))
print(gen1)
print(next(gen1))


# 这个是生成式(x*2 for x in range(5))展开成生成器的写法
def func1():
    for x in range(5):
        yield x * 2


gen3 = (x for x in range(10) if x & 1)
print(gen3)
print(next(gen3))
print(next(gen3))
print(next(gen3))


def func2():
    for x in range(10):
        if x & 1:
            yield x

"""
3.将迭代器和生成器转换成其他序列
"""
list1 = list(gen3)
print(list1)

gen5 = (x.upper() for x in '123assd45dss55d4' if 'a' <= x <= 'z')
list2 = list(gen5)
print(list2)


def yt_list(seq):
    new = []
    for x in seq:
        new.append(x)
    return new

# [生成式] -> 直接将生成式对应的生成器转换成列表
list3 = [x.upper() for x in '123assd45dss55d4' if 'a' <= x <= 'z']
print(list3)

# 练习:交换字典的key和value的位置
dict1 = {'a': 1, 's': 2, 'd': 3}
result = dict((x, y) for y, x in dict1.items())
print(result)


# 注意：遍历字典的时候，字典的长度不能改变。
# 如果遍历字典后对字典的操作会改变字典的长度，那么就不要直接遍历，而是遍历字典的copy

03-homework

# import random
from random import randint

1.编写一个函数，求多个数中的最大值

def yt_max(*nums):
    """求多个数中的最大值"""
    # 20， 9， 8， 45， 0
    max1 = nums[0]
    for num in nums:
        if num > max1:
            max1 = num
    return max1

3.编写一个函数，实现摇色子的功能，打印n个色子的点数和。

def dice(n):
    sum1 = 0
    # 遍历每个色子
    for _ in range(n):
        point = randint(1, 6)
        print('点数:',point)
        sum1 += point
    return sum1

4.编写一个函数，交换指定字典的key和value。

# 例如:{'a':1, 'b':2, 'c':3, 'd': 1} ---> {1:'a', 2:'b', 3:'c'}

# {'a': 'b', 'b': 2, 'c': 3, 'd': 'a'}
"""
第一次取: 'a'
{'b': 2, 'c': 3, 'd': 'a', 'b':'a'}
{'b': 'a', 'c': 3, 'd': 'a'}
"""


# 注意：遍历字典的时候，字典的长度不能改变。
# 如果遍历字典后对字典的操作会改变字典长度，那么就不要直接遍历字典，而是遍历字典的copy
def change(dict1: dict):
    for key in dict1.copy():
        # 先取出键值对
        value = dict1.pop(key)
        # 再交换
        dict1[value] = key

5.编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来

def get_alpha(str1: str):
    new_str = ''
    for char in str1:
        if 'a' <= char <= 'z' or 'A' <= char <= 'Z':
            new_str += char
    print(new_str)


def main():
    print('===============')
    print(yt_max(20, 9, 8, 45, 0))

    print('==============')
    print(dice(3))

    print('===============')
    dict2 = {'a': 'b', 'b': 2, 'c': 3, 'd': 'a'}
    change(dict2)
    print(dict2)

    print('===============')
    get_alpha('wuw892k*92js*uhKls9H')

04-homework2

# 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使 表自带的逆序函数)
def yt_reverse(list1: list):
    """列表逆序"""
    """
    [1,2,3,4,5,6,7]  -> [7,6,5,4,3,2,1]
    len = 7
    0, 6 = len()-0-1
    1, 5 = len()-1-1
    2, 4 = len()-2-1
    3, 3 = len()-2-1, len()//2
    """
    length = len(list1)
    for index in range(length//2):
        list1[index], list1[length-index-1] = list1[length-index-1], list1[index]

2.实现属于自己的字典update方法：用一个字典去更新另一个字典的元素(不能使用自带的update方法)

# yt_update(字典1， 字典2)
def yt_update(dict1: dict, dict2: dict):
    for key in dict2:
        dict1[key] = dict2[key]

3.有一个列表中保存的所一个班的学生信息，使用max函数获取列表中成绩最好的学生信息和年龄最大的学生信息

all_student = [
    {'name': '张三', 'age': 19, 'score': 90},
    {'name': 'stu1', 'age': 30, 'score': 79},
    {'name': 'xiaoming', 'age': 12, 'score': 87},
    {'name': 'stu22', 'age': 29, 'score': 99}
]

print(max(all_student, key=lambda item: item['score']))
print(max(all_student, key=lambda item: item['age']))

def main():
    print('===========第一题============')
    list1 = [1, 2, 3, 4, 5, 6, 7]
    yt_reverse(list1)
    print(list1)

    print('===========第二题============')
    dict1 = {'a': 10, 'b': 20}
    dict2 = {'b': 30, 'c': 40}
    yt_update(dict1, dict2)
    print(dict1)

05-file

1.数据本地化和持久化
将数据以文本的形式存到计算机硬盘中（程序中保存的数据，当程序运行结束会自动销毁）

2.怎么做数据持久化（怎么将程序中的数据和本地文件中的数据关联）
文件读写操作 -  读（获取文件中的内容），写（将数据添加到文件中）

a.文件操作的基本流程：打开文件 - > 文件操作（读/写）-> 关闭文件

3.打开文件
open(file,mode= 'r',encoding='utf-8') ->以指定的模式打开指定的文件，并且返回被打开的文件对象

说明：
file - 字符串，需要打开的文件路径。
       （了解，一般不写）绝对路径：文件在电脑上的完全路径
       相对路径：相对当前代码文件对应的目录来确定的路径
                '致橡树.txt' - ->当前目录下的致橡树.txt
                './致橡树.txt'-->当前目录下的致橡树.txt
                ./->代表的是当前目录，可以省略
                ../->代表当前目录的上层目录
                .../->代表当前目录的上层目录的上层目录

mode - 文件的打开方式
       r - >以只读的形式打开 ，文本（默认）
       w - >以写的形式打开（覆盖），文本
       rb/br - >以只读的形式打开 ，二进制
       wb/bw - >以写的形式打开（覆盖），二进制
       a - >以写的形式打开（追加），文本
       + - >以读写的形式打开

       注意：当以读的方式打开一个不存在的文件，程序会报错
             但是以写的方式打开一个不存在的文件，不会报错，还会自动创建这个文件

encoding - 字符串，文字编码方式
           utf-8: 支持所有语言
           gbk: 只支持英文

        注意：a.读和写对应的编码要保持一致
              b.非文本文件不能设置编码方式，例如：图片，视频，可执行文件等
              c.给它传值的时候要使用关键字参数
              d.以二进制的形式打开文件，不能设置encoding
4.操作文件
a.读操作
文件对象.read() - 获取指定文件中的内容

5.关闭文件
文件对象.close()

6.文件操作的简写 - 打开文件，操作完成后会自动关闭文件
with open(file,mode,encoding)as 文件对象：
     文件操作代码

# a = 10
# a += 100
# print(a)
# ==================1.打开文件=================================
# 2.打开当前目录下的文件：文件名或者./文件名
f = open('致橡树.txt', encoding='utf-8')
print(f.read())

# 打开当前目录下的字目录里面的文件:子目录/文件名 或者 ./字目录文件名
open('file/abc.txt')
open('./file/abc.txt')

# ==================2.打开方式========================================
open('file/a1.txt', 'w')

# ===================3.读操作====================================
# 以'r'方式打开文件，获取文件对象
f = open('致橡树.txt', encoding='utf-8')
# a.读整个文件内容
print(f.read())

f = open('致橡树.txt', 'rb')
print(f.read())  # bytes ->python二进制对应的数据类型

# f = open('致橡树.txt','w+')
# print(f.read())

# b.读一行内容
print('===================================================')
f = open('致橡树.txt', 'r', encoding='utf-8')
print(f.readline())

# 练习：读文件中的内容，一行一行的读，读完为止
f = open('致橡树.txt', 'r', encoding='utf-8')
while True:
    line = f.readline()
    if not line:
        break
    print(line)

# ===================4.写操作===================================
# 如果需要文件进行写操作，那么文件必须以写的方式打开
# w  - >用新的内容覆盖原内容
# a - >在原文件末尾添加新的内容
f = open('致橡树.txt', 'w', encoding='utf-8')
f.write('love you')

# 操作二进制文件
f = open('file/linkJTABLK2W.jpg','rb')
image_data = f.read()
f = open('test.jpg','wb')
f.write(image_data)

# 图片下载过程：请求图片二进制数据，将二进制数据写入本地图片
# 关闭文件
f.close()

06-file2

"""
程序中需要这个数据的时候就从文件中将这个数据读出来
对数据进行了修改之后再将最新的数据保存到文件中

"""

# 用一个变量来保存当前文件执行的次数：第一次执行py文件的时候打印1，
# 第二次执行打印2....
# while True:
#     sum1 = 0
#     with open()

# 将数据从文件中读出来
with open('file/data.txt', encoding='utf-8')as f:
    num = int(f.read())
# 修改数据
num += 1
# 将新的数据在写入文件中
with open('file/data.txt','w', encoding='utf-8')as f:
    f.write(str(num))
# 显示数据
print(num)