Python入门-30、31、32、33、34、35：字符串补充，跳出循环（break、continue），文件（写、读），面向对象的编程（类）

判断密码强弱1.0

案例描述

案例分析

字符串补充

Built-in Types — Python 3.7.2rc1 documentation https://docs.python.org/3/library/stdtypes.html#string-methods

程序及结果

'''
作者：张梦
版本：1.0
功能：判断密码强度
日期：2018.12.22
'''

'''判断是否有数字存在'''
def check_number_exist(password_str):
    for c in password_str:
        if c.isnumeric():
            return True
    return False
# for循环神奇特点：首先这个字符串遍历，如果没有跳出循环的语句，则会一直到字符串结束。但是这里有如果有数字，就会返回true，并且跳出这个子程序，所以字符串后面的也就不遍历了

'''判断是否有字母存在'''
def check_letter_exist(password_str):
    for c in password_str:
        if c.isalpha():
            return True
    return False

'''主函数'''
def main():
    password = input('请输入密码:')
    # 密码强度
    strength_level = 0
    # 规则1：密码长度
    if len(password) >= 8:
        strength_level += 1
    else:
        print('密码长度要求至少8位！')
    # 规则2：包含数字
    if check_number_exist(password):
        strength_level += 1
    else:
        print('密码要求包含数字！')
    # 规则3：包含字母
    if check_letter_exist(password):
        strength_level += 1
    else:
        print('密码要求包含字母！')

    if strength_level == 3:
        print('恭喜！密码强度合格！')
    else:
        print('抱歉！密码强度不合格！')

if __name__ == '__main__':
    main()

Tips

程序如果遇到return，会提前终止程序，跳出这个程序，上面就利用这个写的子程序

思考

• 限制密码设置次数，比如最多尝试5次
• 一个函数里两个return不太规范，如何不用这样，也能终止循环？

判断密码强弱

案例描述2.0

案例分析

（部分结果）

程序及结果

'''
作者：张梦
版本：2.0
功能：判断密码强度
2.0增加功能：限制密码设置次数；循环的终止
日期：2018.12.22
'''

'''判断是否有数字存在'''
def check_number_exist(password_str):
    has_number = False
    for c in password_str:
        if c.isnumeric():
            has_number = True
            break
    return has_number
# for循环神奇特点：首先这个字符串遍历，如果没有跳出循环的语句，则会一直到字符串结束。但是这里有如果有数字，就会返回true，并且跳出这个子程序，所以字符串后面的也就不遍历了

'''判断是否有字母存在'''
def check_letter_exist(password_str):
    has_letter = False
    for c in password_str:
        if c.isalpha():
            has_letter = True
            break
    return  has_letter

'''主函数'''
def main():

    try_time = 5
    while try_time > 0:
        password = input('请输入密码:')
        # 密码强度
        strength_level = 0
        # 规则1：密码长度
        if len(password) >= 8:
            strength_level += 1
        else:
            print('密码长度要求至少8位！')
        # 规则2：包含数字
        if check_number_exist(password):
            strength_level += 1
        else:
            print('密码要求包含数字！')
        # 规则3：包含字母
        if check_letter_exist(password):
            strength_level += 1
        else:
            print('密码要求包含字母！')

        if strength_level == 3:
            print('恭喜！密码强度合格！')
            break
        else:
            print('抱歉！密码强度不合格！')
            try_time -= 1
        print()

    if try_time <= 0:
        print('尝试次数过多，密码设置失败！')

if __name__ == '__main__':
    main()

思考

保存设置的密码及强度到文件中

判断密码强弱

案例描述3.0

案例分析

文件

文件相关概念

打开（新建）文件

注意：w 是重新写入，不保存之前的内容！

写入操作

注意写入文件这段代码的位置，放在下面这里，结果会少一行，因为break所以成功的那个不会写入文件

正确程序：

程序及结果

'''
作者：张梦
版本：3.0
功能：判断密码强度
2.0增加功能：限制密码设置次数；循环的终止
3.0增加功能：保存密码及强度到文件中
日期：2018.12.22
'''

'''判断是否有数字存在'''
def check_number_exist(password_str):
    has_number = False
    for c in password_str:
        if c.isnumeric():
            has_number = True
            break
    return has_number
# for循环神奇特点：首先这个字符串遍历，如果没有跳出循环的语句，则会一直到字符串结束。但是这里有如果有数字，就会返回true，并且跳出这个子程序，所以字符串后面的也就不遍历了

'''判断是否有字母存在'''
def check_letter_exist(password_str):
    has_letter = False
    for c in password_str:
        if c.isalpha():
            has_letter = True
            break
    return  has_letter

'''主函数'''
def main():

    try_time = 5
    while try_time > 0:
        password = input('请输入密码:')
        # 密码强度
        strength_level = 0
        # 规则1：密码长度
        if len(password) >= 8:
            strength_level += 1
        else:
            print('密码长度要求至少8位！')
        # 规则2：包含数字
        if check_number_exist(password):
            strength_level += 1
        else:
            print('密码要求包含数字！')
        # 规则3：包含字母
        if check_letter_exist(password):
            strength_level += 1
        else:
            print('密码要求包含字母！')

        # 写入文件
        f = open('password_3.0.txt', 'a')
        f.write('密码：{}，强度：{}\n'.format(password, strength_level))
        # f.write(password + '\n')
        f.close()

        if strength_level == 3:
            print('恭喜！密码强度合格！')
            break
        else:
            print('抱歉！密码强度不合格！')
            try_time -= 1
        print()


    if try_time <= 0:
        print('尝试次数过多，密码设置失败！')

if __name__ == '__main__':
    main()

结果：


结果：
Python里面打不开，因为有中文

从路径里打开就能看到了

思考

读取保存文件

判断密码强弱

案例描述4.0

案例分析

文件

读取操作

1. read()
   
   
   
2. readline()
   缺点：一行一行的读取，无法知道第几行才结束，无法遍历完
   
   
   
3. readlines()
   读出的是列表形式
   
   
4. 文件的遍历
   一行一行的操作，整个文件都操作一遍
   （有三种写法）
   一：
   
   二：
   
   三：
   
   结果：
   

程序

'''
作者：张梦
版本：4.0
功能：判断密码强度
2.0增加功能：限制密码设置次数；循环的终止
3.0增加功能：保存密码及强度到文件中
4.0增加功能：读取保存的密码
日期：2018.12.23
'''

'''主函数'''
def main():

    # 读取文件
    f = open('password_3.1.txt', 'r')

    # # 1.read()
    # content = f.read()
    # f.close()
    # print(content)

    # # 2.readline
    # line = f.readline()
    # print(line)
    # line = f.readline()
    # print(line)
    # f.close()

    # # 3.readines()
    # line = f.readlines()
    # print(line)
    # f.close()

    # 4.文件的遍历
    for linea in f:
        print('read:{}'.format(linea))
    f.close()

if __name__ == '__main__':
    main()

思考

与密码操作相关的能否封装成一个整体？

判断密码强弱

案例描述5.0

案例分析

面向过程VS面向对象

注意：类名一般都是大写并且不加下划线！！

只要是在类里面定义的行数，参数都要加上self，这个是规范！所以上面的程序改为如下：

因为只要在类里定义了，下面的都可以用，所以也可改成如下：

类的调用：

程序及结果

'''
作者：张梦
版本：5.0
功能：判断密码强度
2.0增加功能：限制密码设置次数；循环的终止
3.0增加功能：保存密码及强度到文件中
4.0增加功能：读取保存的密码
4.0增加功能：将相关方法封装成一个整体：面向对象编程——定义一个password工具类
日期：2018.12.23
'''

'''密码工具类'''
class PasswordTool:
    def __init__(self, password):
        # 类的属性
        self.password = password
        self.strength_level = 0

    def process_password(self):
        # 规则1：密码长度
        if len(self.password) >= 8:
            self.strength_level += 1
        else:
            print('密码长度要求至少8位！')
        # 规则2：包含数字
        if self.check_number_exist():
            self.strength_level += 1
        else:
            print('密码要求包含数字！')
        # 规则3：包含字母
        if self.check_letter_exist():
            self.strength_level += 1
        else:
            print('密码要求包含字母！')

    # 类的方法
    '''判断是否有数字存在'''
    def check_number_exist(self):
        has_number = False
        for c in self.password:
            if c.isnumeric():
                has_number = True
                break
        return has_number

    '''判断是否有字母存在'''
    def check_letter_exist(self):
        has_letter = False
        for c in self.password:
            if c.isalpha():
                has_letter = True
                break
        return has_letter

'''主函数'''
def main():

    try_time = 5
    while try_time > 0:
        password = input('请输入密码:')
        # 实例化密码工具对象
        password_tool = PasswordTool(password)
        password_tool.process_password()

        # 写入文件
        f = open('password_3.1.txt', 'a')
        f.write('密码：{}，强度：{}\n'.format(password, password_tool.strength_level))
        # f.write(password + '\n')
        f.close()

        if password_tool.strength_level == 3:
            print('恭喜！密码强度合格！')
            break
        else:
            print('抱歉！密码强度不合格！')
            try_time -= 1
        print()

    if try_time <= 0:
        print('尝试次数过多，密码设置失败！')

if __name__ == '__main__':
    main()

判断密码强弱

案例描述6.0

案例分析

面向对象的特点

程序及结果

'''
作者：张梦
版本：5.0
功能：判断密码强度
2.0增加功能：限制密码设置次数；循环的终止
3.0增加功能：保存密码及强度到文件中
4.0增加功能：读取保存的密码
5.0增加功能：将相关方法封装成一个整体：面向对象编程——定义一个password工具类
6.0增加功能：定义一个文件工具类，将文件封装到一个类中
日期：2018.12.27
'''

'''密码工具类'''
class PasswordTool:
    def __init__(self, password):
        # 类的属性
        self.password = password
        self.strength_level = 0

    def process_password(self):
        # 规则1：密码长度
        if len(self.password) >= 8:
            self.strength_level += 1
        else:
            print('密码长度要求至少8位！')
        # 规则2：包含数字
        if self.check_number_exist():
            self.strength_level += 1
        else:
            print('密码要求包含数字！')
        # 规则3：包含字母
        if self.check_letter_exist():
            self.strength_level += 1
        else:
            print('密码要求包含字母！')

    # 类的方法
    '''判断是否有数字存在'''
    def check_number_exist(self):
        has_number = False
        for c in self.password:
            if c.isnumeric():
                has_number = True
                break
        return has_number

    '''判断是否有字母存在'''
    def check_letter_exist(self):
        has_letter = False
        for c in self.password:
            if c.isalpha():
                has_letter = True
                break
        return has_letter

'''文件工具类'''
class FileTool:
    def __init__(self, filepath):
        self.filepath = filepath

    # 写文件
    def write_to_file(self,line):
        f = open(self.filepath, 'a')
        f.write(line)
        f.close()

    # 读取整个文件
    def read_from_file(self):
        f = open(self.filepath, 'r')
        lines = f.readlines()
        f.close()
        return lines

'''主函数'''
def main():

    try_time = 5
    filepath = 'password_6.0.txt'
    # 实例化文件工具类对象
    file_tool = FileTool(filepath)

    while try_time > 0:
        password = input('请输入密码:')
        # 实例化密码工具对象
        password_tool = PasswordTool(password)
        password_tool.process_password()

        line = '密码：{}，强度：{}\n'.format(password, password_tool.strength_level)
        # 写操作
        file_tool.write_to_file(line)

        if password_tool.strength_level == 3:
            print('恭喜！密码强度合格！')
            break
        else:
            print('抱歉！密码强度不合格！')
            try_time -= 1
        print()

    if try_time <= 0:
        print('尝试次数过多，密码设置失败！')

    # 读操作
    lines = file_tool.read_from_file()
    print(lines)

if __name__ == '__main__':
    main()

小结