作业

作业

一、必做题

1、第1题：使用while循环输出1 2 3 4 5 6 8 9 10

'''
错误：看错题目以为1~10
# 初始值为1
n = 1

while n < 11:  # n的范围1~10
    print(n, end=' ')
    n += 1
'''
# 订正
# 注意：print默认换行打印，取消它print(end=' ')

# 初始值为1
n = 1

while n < 11:  # n的范围1~10
    # 判断：如果n等于7时，不打印
    if n == 7:
        n += 1
        continue
    print(n, end=' ')
    n += 1

2、第2题：求1-100的所有数的和

# 初始值求1-100的所有数的和为1
num = 1
# 和初始值为0
sum_num = 0

while num < 101:  # num的范围1~100
    # 每次自增1的num，增量到sum_num中
    sum_num += num
    num += 1

print('sum_num:', sum_num)

3、第3题：输出 1-100 内的所有奇数

# 初始值为1
is_odd = 1

while is_odd < 101:  # is_odd的范围1~100
    # 作为条件：偶数除以2取余为0，布尔值为False，奇数就是1，布尔值为True
    if is_odd % 2:
        print('odd:', is_odd)

    # 保证每次都自增1，只有奇数会打印
    is_odd += 1

4、第4题：输出 1-100 内的所有偶数

# 初始值为1
is_even = 1

while is_even < 101:  # is_even的范围1~100
    # 作为条件：偶数除以2取余为0，布尔值为False，奇数就是1，布尔值为True
    if not is_even % 2:
        print('even:', is_even)

    # 保证每次都自增1，只有偶数会打印
    is_even += 1

5、第5题：求1-2+3-4+5 ... 99的所有数的和

'''
错误: 看错题目以为是1~99的和。。。。
# 初始值1
num = 1
# 和的初始值0
sum_num = 0

while num < 100:    # num范围1~99
    # num每次自增1，都为sum_num作为当前的增量相加
    sum_num += num
    num += 1
print('sum_num:', sum_num)
'''
# 订正

# 初始值1
num = 1
# 和的初始值0
sum_num = 0

while num < 100:    # num范围1~99
    # num范围1~99中，只要遇到奇数就 +
    if num % 2:  # 奇数取余为1，条件为True
        sum_num += num
        
    # num范围在1~99中，只要遇到偶数就 —
    else:   # 剩下的就是偶数了
        sum_num -= num
    num += 1
print('sum_num:', sum_num)

6、第6题：用户登陆（三次机会重试）

# 添加用户账户
username = 'wangmao'
password = '123'
# 记录错误的初始值，错误初始为0
wrong_number = 0

while wrong_number < 3: # 错误次数范围0~2，共3次时
    inp_username = input("输入用户账号>>:")
    inp_password = input("输入用户密码>>:")

    # 验证：失败记录次数，成功跳出循环
    if inp_username == username and inp_password == password:
        print('登录成功')
        break
    else:
        print('登录失败，账号或者密码错误')
        wrong_number += 1

7、第7题：猜年龄游戏

'''
要求：
允许用户最多尝试3次，3
次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出
'''

# 用户要猜的是年龄，定义年龄
age = 18
# 变量的初始化，记录错误次数的初始值为0
wrong_number = 0

while wrong_number < 3: # 错误的范围0~2,只能保证错误3次
    guess_age = input('猜猜我不是王毛的年龄>>:')
    if guess_age.isdigit():
        guess_age = int(guess_age)
        if guess_age == age:
            print('猜对了，恭喜！')
            break
        elif guess_age < age:
            print('猜小了')
        else:
            print('猜大了')
    wrong_number += 1
    print('最多尝试3次,目前错误：%s次' % wrong_number)

8、第8题：猜年龄游戏升级版

写法一

• 循环条件使用：True，运用if判断产式次数 + break,来结束循环

"""
要求：
允许用户最多尝试3次
每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
如何猜对了，就直接退出
"""

# 用户要猜的是年龄，定义年龄
age = 18
# 变量的初始化，记录错误次数的初始值为0
wrong_number = 0

while True:  # 由用户是否继续来控制循环，条件不能用上面的
    # 每次循环一开始，就先判断用户错误次数，继续重置，错误次数为0.不继续退出
    if wrong_number == 3:
        is_continue = input("是否继续，继续：Y/y。不继续：N/n：")
        # if is_continue == 'Y' and is_continue == 'y':
        if is_continue.lower() == 'y':
            wrong_number = 0
            print('请继续play！！！')
        elif is_continue.lower() == 'n':
            print('程序退出。。。')
            break
        else:
            print('输入错误，继续输入Y或y, 不继续输入N或n')
            continue

    guess_age = input('猜猜我不是王毛的年龄>>:')
    if guess_age.isdigit():
        guess_age = int(guess_age)
        if guess_age == age:
            print('猜对了，恭喜！')
            break
        elif guess_age < age:
            print('猜小了')
        else:
            print('猜大了')
    wrong_number += 1
    print('最多尝试3次,目前错误：%s次' % wrong_number)

写法二

• 循环条件使用：比较运算，运用尝试次数达到3次，来结束循环

"""
要求：
允许用户最多尝试3次
每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
如何猜对了，就直接退出
"""

# 用户要猜的是年龄，定义年龄
age = 18
# 变量的初始化，记录错误次数的初始值为0
wrong_number = 0

while wrong_number < 3:  # 错误次数控制循环，错误范围0~2，共3次
    guess_age = input('猜猜我不是王毛的年龄>>:')
    if guess_age.isdigit():
        guess_age = int(guess_age)
        if guess_age == age:
            print('猜对了，恭喜！')
            break
        elif guess_age < age:
            print('猜小了')
        else:
            print('猜大了')
    wrong_number += 1
    print('最多尝试3次,目前错误：%s次' % wrong_number)

    # 每次循环一结束，就先判断用户错误次数，继续重置错误次数为0.不继续退出
    if wrong_number == 3:
        while True:
            is_continue = input("是否继续，继续：Y/y。不继续：N/n：")
            # if is_continue == 'Y' and is_continue == 'y':
            if is_continue.lower() == 'y':
                wrong_number = 0
                print('请继续play！！！')
                break
            elif is_continue.lower() == 'n':
                print('程序退出。。。')
                exit()
            else:
                print('输入错误，继续输入Y或y, 不继续输入N或n')

9、第9题：编写用户登录接口

写法一

• 用户账户信息account_info与用户错误次数wrong_user，分成2个字典来。wrong_user是个空字典，表示所有用户开始没有错误记录

"""
需求：
1、输入账号密码完成验证，验证通过后输出"登录成功"
2、可以登录不同的用户
3、同一账号输错三次锁定
"""

# 添加不同用户
account_info = {
    'wangmao': '123',
    'egon': '123',
    'alex': 'alex3714'
}
# 记录用户账号对应对错误次数
wrong_user = {}

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')
    # 每次用户输入，查看用户错误账户中的错误次数是否达到3次
    if inp_username in wrong_user:
        if wrong_user.get(inp_username) == 3:
            print('该用户，错误次数已经达到3次，该账号已经被锁定，无法登录。')
            continue

    if inp_username in account_info:
        if account_info.get(inp_username) == inp_password:
            # 登录成功情清空当前，用户之前输错的次数(注意：用户可能之前一次没错，wraong_user中没有该数据)
            if inp_username in wrong_user:
                del wrong_user[inp_username]
            print('登录成功:', inp_username)
        else:
            # 如果用户是第一次错误，则wrong_user中没有他的key，有则加1
            current_user = wrong_user.get(inp_username)
            if current_user:
                wrong_user[inp_username] += 1
            else:
                wrong_user[inp_username] = 1
            print('登录失败，密码错误，错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (inp_username, wrong_user[inp_username]))
    else:
        print('用户不存在。。。。')

写法二 （推荐）

• 建立用户账户信息account_info，以“用户名”作为字典的key，以用户信息（包含密码）作为字典的value，其中第一个是密码，第二是用户当前错误次数

"""
需求：
1、输入账号密码完成验证，验证通过后输出"登录成功"
2、可以登录不同的用户
3、同一账号输错三次锁定
"""

account_info = {
    # 以“用户名”作为字典的key，以用户信息（包含密码）作为字典的value，其中第一个是密码，第二是用户当前错误次数
    'wangmao': ['123', 0],
    'egon': ['123', 0],
    'alex': ['alex3714', 0],
}

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')

    if inp_username in account_info:
        info_list = account_info.get(inp_username)
        # 1、判断用户错误次数是否超出需要锁定
        if info_list[-1] == 3:
            print('该用户，错误次数已经达到3次，该账号已经被锁定，无法登录。')
            continue

        if info_list[0] == inp_password:
            # 2、登录成功之前，无论把该用户之前是否存在错误，都将他的引用计数修改为初始状态
            info_list[-1] = 0
            print('登录成功:', inp_username)
            break
        else:   # 3、密码核对错误
            info_list[-1] += 1
            # python3.5以后版本的格式化方法： f'文本内容。。。{插入格式化字符}文本内容。。。'
            print(f'登录失败，密码错误，同一账号错误次数达到3次账号锁定，当前用户：{inp_username} 错误次数：{info_list[-1]}')
            # print('登录失败，密码错误，同一账号错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (inp_username, wrong_number)
    else:
        print('用户不存在。。。。')

二、选做题1

写法一

• 用户账户信息account_info与用户错误次数wrong_user，分成2个字典来。wrong_user是个空字典，表示所有用户开始没有错误记录

"""
选做题1：
    针对题目9附加功能
    在程序一直运行的情况下，一旦锁定，则锁定5分钟后自动解锁
"""

import time
# 添加不同用户
account_info = {
    'wangmao': '123',
    'egon': '123',
    'alex': 'alex3714'
}
# 用户账号对应对错此处
wrong_user = {}

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')
    
    if inp_username in account_info:
        # 1、当账户存在时：查看用户错误账户中的错误次数是否达到3次，达到锁定需求，则锁定，且解锁以后清除该用户的错误次数。
        if wrong_user.get(inp_username) == 3:
            print('该用户，错误次数已经达到3次，该账号已经被锁定，锁定时间3秒')
            time.sleep(3)   # 这里用3秒代替
            del wrong_user[inp_username]    # 锁定3秒以后，清除数据中的该用户
            continue
        
        # 2、核对账户密码正确性    
        if account_info.get(inp_username) == inp_password:
            # 2.1、登录成功清空当前用户之前输错的次数(注意：用户可能之前一次没错，一次性输对，wraong_user中没有该数据，所以要进行判断，有错误数据则清除)
            if inp_username in wrong_user:
                del wrong_user[inp_username]
            print('登录成功:', inp_username)
        else:
            # 2.2、注意:如果用户是第一次错误，则wrong_user中没有它的key，有则加1，没有则初始化赋值1
            current_user = wrong_user.get(inp_username)
            if current_user:
                wrong_user[inp_username] += 1
            else:
                wrong_user[inp_username] = 1
            print('登录失败，密码错误，错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (inp_username, wrong_user[inp_username]))
    else:
        print('用户不存在。。。。')

写法二 (推荐)

• 以“用户名”作为字典的key，以“用户信息”作为字典的value, 而用户信息可以用字典来存，立面可以放，用户密码、用户输入错误数、用户锁定状态等等。。。

"""
选做题1：
    针对题目9附加功能
    在程序一直运行的情况下，一旦锁定，则锁定5分钟后自动解锁
"""
account_info = {
    'wangmao': {'password': '123', 'wrong_number': 0},
    'alex': {'password': 'alex3714', 'wrong_number': 0},
    'egon': {'password': '123', 'wrong_number': 0},
}

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')

    if inp_username in account_info:
        user_info = account_info.get(inp_username)
        wrong_number = user_info.get('wrong_number')
        # 1、用户账号验证成功的第一件事，就是验证该账户的错误次数是否达标，如果达标则,锁定，解锁完毕以后要重置该用户的错误次数为0
        if wrong_number == 3:
            print('该用户，错误次数已经达到3次，该账号已经被锁定，锁定时间3秒')
            import time
            time.sleep(3)
            user_info['wrong_number'] = 0
            continue

        # 2、核对密码：密码赋值放到账户验证后，验证不通过，密码这行及以下代码，也不需要执行了,且登录成功，错误次数也要重置
        user_password = user_info.get('password')
        if user_password == inp_password:
            print('登录成功:', inp_username)
            user_info['wrong_number'] = 0
        else:
            user_info['wrong_number'] += 1
            print('登录失败，密码错误，错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (inp_username, user_info['wrong_number']))
    else:
        print('用户不存在。。。。')

三、选做题2

写法一

• 只把用户账户，密码放到一起，只把用户错误信息记录放到一起。
• 优点:运用了，修改文件操作
• 缺点：账户信息，没有放到一起关联。每个用户错误次数记录，都因该是不一样的，而不是公用的。多次修改文件操作，多次读出，存进，文件量大的情况下，本方法就不适用了。

"""
针对题目9升级需求：
    完成用户一旦锁定，无论程序是否关闭，都锁定5分钟
解析：
    关于程序无论是否关闭，都锁定，因该把用户对应错误存放到文件中，每次循环开始执行时，第一件事，先看看文件中该用户，是否已经是被锁定的
"""

# 添加不同用户
account_info = {
    'wangmao': '123',
    'egon': '123',
    'alex': 'alex3714'
}

# 用户错误文件
account_wrong_file = r'wrong_user.txt'

# 需要多次做修改文件操作，所以设置个交换文件地址
swap_file = r'swap.txt'

# 重置时，定一个变量，控制，程序直接进入下一次循环
is_reset = False

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')

    # 1、每次用户输入，查看用户错误账户中的错误次数是否达到3次，判断用户错误记录文件是否存在，存在的话，就打开文件查看，不存在创建该文件
    import os
    if os.path.isfile(account_wrong_file):
        # 1.1、修改文件操作：如果文件存在时，需要读出用户错误文件，查看用户的错误次数，如果错误次数达到锁定需求，则锁定该用户3秒。接着锁定时间结束以后，重置用户错误锁定次数
        with open(account_wrong_file, 'r') as f_read, open(swap_file, 'w') as f_write:
            # 读出原文件
            wrong_user = eval(f_read.read())
            if inp_username in wrong_user:
                if wrong_user.get(inp_username) == 3:
                    print('该用户，错误次数已经达到3次，该账号已经被锁定，锁定时间3秒')
                    import time

                    time.sleep(3)  # 这里用3秒代替
                    # 锁定3秒以后，清除数据中的该用户
                    del wrong_user[inp_username]
                    is_reset = True
            # 存入新文件
            f_write.write('%s' % wrong_user)
        # 1.2、删除原文件
        os.remove(account_wrong_file)
        # 1.3、把交换文件重命名，为原文件名
        os.rename(swap_file, account_wrong_file)

    # 2、注意：文件不存在时，文件中只有{}，才能满足上面文件循环所需要的
    else:
        with open(account_wrong_file, 'w') as f:
            f.write('%s' % {})

    if inp_username in account_info:
        if account_info.get(inp_username) == inp_password:
            # 3、修改文件操作：用户登录成功时，需要读出用户错误文件，进行适当的错误删除重置操作
            with open(account_wrong_file, 'r') as f_read, open(swap_file, 'w') as f_write:
                # 读出原文件
                wrong_user = eval(f_read.read())
                # 读出文件：立刻，拿到用户错误信息，先判断该用户在不在里面。如果不在说明用户是第一次就登录成功了。如果在说明用户之前有登录错误次数记录，所以要清空该用户的错误信息，再保存到文件中
                if inp_username in wrong_user:
                    del wrong_user[inp_username]
                # 存入新文件
                f_write.write(f'{wrong_user}')
                print('登录成功:', inp_username)
            # 3.1、删除原文件
            os.remove(account_wrong_file)
            # 3.2、把交换文件重命名，为原文件名
            os.rename(swap_file, account_wrong_file)

        else:
            # 4、重置以后，占时不执行：解决了上面if语句执行完以后，出现不必要跳转到该行的操作
            if not is_reset:
                # 5、修改文件操作：用户输入错误时，需要读出用户错误文件，进行适当的错误添加操作
                with open(account_wrong_file, 'r') as f_read, open(swap_file, 'w') as f_write:
                    # 读出原文件
                    wrong_user = eval(f_read.read())
                    current_user = wrong_user.get(inp_username)
                    # 注意: 如果用户没有错误记录，需要手动设置初始错误值1。如果用户有错误记录，就可以在原来的基础之上自增+1。
                    if current_user:
                        wrong_user[inp_username] += 1
                    else:
                        wrong_user[inp_username] = 1
                    # 存入新文件
                    f_write.write('%s' % wrong_user)
                    print('登录失败，密码错误，错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (inp_username, wrong_user[inp_username]))
                # 5.1、删除原文件
                os.remove(account_wrong_file)
                # 5.2、把交换文件重命名，为原文件名
                os.rename(swap_file, account_wrong_file)
            else:
                is_reset = False
    else:
        print('用户不存在。。。。')

写法二

• 以“用户名”作为字典的key，以“用户信息”作为字典的value，然尔‘用户信息’也以字典的形式存，包含了当前用户的密码，账号错误次数，登录状态等
• 优点：把用户信息与用户捆绑，只要用户登录，就能时时记录用户当前的状态
• 缺点：如果用户太多，文件太大，文件的每次进行操作都需要，读出源文件，修改，覆盖源文件，不太推荐。

"""
针对题目9升级需求：
    完成用户一旦锁定，无论程序是否关闭，都锁定5分钟
解析：
    关于程序无论是否关闭，都锁定，因该把用户对应错误存放到文件中，每次循环开始执行时，第一件事，先看看文件中该用户，是否已经是被锁定的
"""

"""
创建account_info.txt文件把以下代码放入文件中：
{
    'wangmao': {'password': '123', 'wrong_number': 0},
    'alex': {'password': 'alex3714', 'wrong_number': 0},
    'egon': {'password': '123', 'wrong_number': 0},
    'tank': {'password': '123', 'wrong_number': 0},
}
"""


# 定义用户账户信息地址，可能需要多次打开文件，多次使用文件路径
account_file = r'account_info.txt'

# 定义用户最多错误数
max_wrong = 3

# 定义用户初始状态
init_wrong = 0

while True:
    # 每次循环，都需要把用户账户信息先加载到内存
    with open(account_file, 'r') as f:
        account_info = eval(f.read())

    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')

    if inp_username in account_info:
        user_info = account_info.get(inp_username)
        user_wrong_number = user_info.get('wrong_number')
        if user_wrong_number == max_wrong:
            import time

            print('该用户，错误次数已经达到3次，该账号已经被锁定，锁定时间3秒')
            time.sleep(3)  # 这里用3秒代替
            # 锁定3秒以后，把该用户错误记录重置为初始状态，再把用户文件覆盖，重新写入,再进行下一次循环，让用户输入
            account_info.get(inp_username)['wrong_number'] = init_wrong
            with open(account_file, 'w') as f:
                f.write(f'{account_info}')
            continue

        user_password = user_info.get('password')
        if user_password == inp_password:
            # 核验密码登录成功：重置用户错误记录，无论用户之前是错了几次, 再把原用户文件覆盖，重新写入，再进行下一次循环，让用户输入
            account_info.get(inp_username)['wrong_number'] = init_wrong
            with open(account_file, 'w') as f:
                f.write(f'{account_info}')
            print('登录成功:', inp_username)
        else:
            # 核验密码登录失败：争对用户错误次数进行自增+1,再把源文件覆盖，重新写入
            account_info.get(inp_username)['wrong_number'] += 1
            with open(account_file, 'w') as f:
                f.write(f'{account_info}')
            print('登录失败，密码错误，错误次数达到3次账号锁定，当前用户：%s 错误次数：%s' % (
                inp_username, account_info.get(inp_username)['wrong_number']))
    else:
        print('用户不存在。。。。')

写法三(最终实现)

• 文件存储形式改变，以字典的形式把每个用户的信息，存成一行，每一行代表一个用户的信息，全部在文件打开中实现操作，解决了文件过大出现占用内存的问题。
• 程序中存放用户当前的登录状态，可以让登录过的用户，不需要继续登录
• 程序解决了需要手动创建文件的问题，自动把用户的初始账户数据存入文件，记录用户当前的状态，时时记录每个用户登录之前的登录错误次数。

"""
针对题目9升级需求：
    完成用户一旦锁定，无论程序是否关闭，都锁定5分钟
解析：
    关于程序无论是否关闭，都锁定，因该把用户对应错误存放到文件中，每次循环开始执行时，第一件事，先看看文件中该用户，是否已经是被锁定的
"""

# 定义用户账户，初始数据
account_info = """
{'username': 'wangmao', 'password': '123', 'wrong_number': 0, 'is_succeed': False}
{'username': 'alex', 'password': 'alex3714', 'wrong_number': 0, 'is_succeed': False}
{'username': 'egon', 'password': '123', 'wrong_number': 0, 'is_succeed': False}
"""

account_info = """
{'username': 'wangmao', 'password': '123', 'wrong_number': 0}
{'username': 'alex', 'password': 'alex3714', 'wrong_number': 0}
{'username': 'egon', 'password': '123', 'wrong_number': 0}
"""

# 定义用户账户信息地址，及交换文件，可能需要多次打开文件，多次使用文件路径
account_file = r'accounts.txt'
swap_file = r'swap.txt'

# 定义用户最多错误数
max_wrong = 3

# 定义用户初始状态
init_wrong = 0

# 定义用户当前登录状态
logging_status = {}

# 程序加载，判断文件存不存在，文件不存在当前目录下，则把战虎初始数据写入
import os
if not os.path.isfile(account_file):
    with open(account_file, 'w') as f:
        f.write(account_info)

while True:
    inp_username = input('请输入账号>>:')
    inp_password = input('请输入密码>>:')

    with open(account_file, 'r') as f_read, open(swap_file, 'w') as f_write:
        for line in f_read:
            # 可能这一行只有一个换行符\n：判断存在性，存在跳过该行
            if not len(line.strip()):
                continue

            accounts = eval(line.split(r'\n')[0])  # 每行都有换行符
            # '1' != 'egon' or 1 != '123'     True
            # '1' != 'egon' or '123' != '123' True
            # 'egon' != 'egon' or '123' != '123'
            if inp_username != accounts.get('username') or inp_password != accounts.get('password'):
                # 认证失败：把是认证用户失败的那个用户记录他的错误次数， 再写入交换文件
                if inp_username == accounts.get('username'):
                    accounts["wrong_number"] += 1
                    print(f'登录失败，密码错误，错误次数达到3次账号锁定，当前用户：{inp_username} 错误次数：{accounts["wrong_number"]}')

                    # 认证是该用户: 那么要判断用户之前错误记录，是否达到要锁定的级别，达到锁定锁定3秒，解锁以后初始化锁定次数为0
                    if accounts.get('wrong_number') == max_wrong:
                        print(f'该用户{inp_username}，错误次数已经达到3次，该账号已经被锁定，锁定时间3秒...')
                        import time
                        time.sleep(3)  # 这里用3秒代替
                        accounts['wrong_number'] = init_wrong
                        print(f'用户{inp_username}解锁成功！！！')

                f_write.write(f'{accounts}\n')
                continue
            # 账号密码输入正确， 判断锁定状态之前，先判断该用户是否认证成功，认证成功以后不需要再次认证
            if inp_username in logging_status and logging_status.get(inp_username):
                print(f'{inp_username}欢迎再次登录!!!')
                break

            # 账号密码输入正确：登录成功，登录成功初始化锁定次数为0
            print('登录成功:', inp_username)
            accounts['wrong_number'] = init_wrong
            logging_status[inp_username] = True   # 认证成功，添加用户当前认证状态
            f_write.write(f'{accounts}\n')

    os.remove(account_file)
    os.rename(swap_file, account_file)

四、总结

• print默认换行打印，取消它print(end=' ')

• 涉及到奇偶性问题：可以使用取余法，奇数%2取余一定等于1，偶数%2取余一定等于0

• python3.5以后版本的格式化方法： age = 18 print(f'我的年龄是{age}岁')

• 涉及到几次怎么怎么样：要先定义初始值，达到满足某种条件时，要进行初始值变量的自增赋值运算

• 存储用户账户，可以以字典的形式来存储，可以为每个用户定制每个用户的错误信息，每个用户的错误次数，每个用户的登录状态，等等。。。

• 涉及到锁定5分钟：可以导入time模块，使用time.sleep(时间:int)

• 涉及到程序无论关闭都保存状态：都要考虑到文件操作，把数据保存到文件中，可以及时的保存许多用户的当前状态，方便以后程序继续运行时，某些数据不会重置。

• for文件中的循环每一行时：

  # 错误示例
  for line in f:
  	line.split('\n')
  
  # 注意：可能当前行为空行，不能进行split操作，需要判断当前行是否为空行
  # 修改
  for line in f:
  	if not len(line.strip()):
  		continue
  	line.split('\n')