Python判断密码不以数字开头 python判断密码字符串强度

判断密码强弱 1.0

Python字符串

更多isxxx()方法请参考：

https://docs.python.org/3/library/stdtypes.html#string-methods注意：

直接判断是判断字符串是否只由字母/数字组成：

想要判断字符串是否包含字母/数字，要写循环一个一个字符判断

（print处修改就可以判断了）：

关于Python console 多行命令执行：两个回车键

v_1.0代码如下：

"""
    作者：xpt
    功能：判断密码强弱
    版本：1.0
    日期：21/11/2018
"""


def check_number_exist(password_str):
    """
    判断密码是否包含数字
    """
    for x in password_str:
        if x.isnumeric():
            return True
    return False


def check_alpha_exist(password_str):
    """
    判断密码是否包含数字
    """
    for x in password_str:
        if x.isalpha():
            return True
    return False


def main():
    """
    主函数
    """
    password = input('请输入密码：')

    # 密码强度
    strength_level = 0

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

    # 字符强度是否满足要求
    if strength_level == 3:
        print("密码强度合格！")
    else:
        print("密码强度不合格！")


if __name__ == '__main__':
    main()

• 限制密码设置次数，比如最多尝试设置5次
• 如何终止循环？

判断密码强弱 2.0–增加功能：限制密码设置次数；循环的终止

循环的终止-break&continue

v_2.0代码如下：

使用break修改函数：

"""
    作者：xpt
    功能：判断密码强弱
    版本：2.0
    日期：21/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
"""


def check_number_exist(password_str):
    """
    判断密码是否包含数字
    """
    has_number = False
    for x in password_str:
        if x.isnumeric():
            has_number = True
            break
    return has_number


def check_alpha_exist(password_str):
    """
    判断密码是否包含数字
    """
    has_alpha = False
    for x in password_str:
        if x.isalpha():
            has_alpha = True
            break
    return has_alpha


def main():
    """
    主函数
    """
    try_time = 3  # 设置密码尝试次数
    while try_time > 0:
        password = input('请输入密码：')

        # 密码强度
        strength_level = 0

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

        # 字符强度是否满足要求
        if strength_level == 3:
            print("恭喜，密码强度合格！")
            break
        else:
            print("密码强度不合格！")
            try_time -= 1
        print()
    if try_time <= 0:
        print()
        print('尝试次数过多，密码设置失败！')


if __name__ == '__main__':
    main()

• 保存设置的密码及其对应的强度到文件中

判断密码强弱 3.0–增加功能：保存设置的密码及其对应的强度到文件中

文件

文件写操作

文件操作注意点：

文件名要加引号！文件操作模式也要加引号！

open函数打开文件之后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的。

v_3.0代码如下：

"""
    作者：xpt
    功能：判断密码强弱
    版本：3.0
    日期：21/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
    3.0增加功能：保存设置的密码及其对应的强度到文件中
"""


def check_number_exist(password_str):
    """
    判断密码是否包含数字
    """
    has_number = False
    for x in password_str:
        if x.isnumeric():
            has_number = True
            break
    return has_number


def check_alpha_exist(password_str):
    """
    判断密码是否包含数字
    """
    has_alpha = False
    for x in password_str:
        if x.isalpha():
            has_alpha = True
            break
    return has_alpha


def main():
    """
    主函数
    """
    try_time = 3  # 设置密码尝试次数
    while try_time > 0:
        password = input('请输入密码：')

        # 密码强度
        strength_level = 0

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

        f = open('password.txt', 'a')
        f.write('密码：{}，强度:{}\n'.format(password,strength_level))
        f.close()

        # 字符强度是否满足要求
        if strength_level == 3:
            print("恭喜，密码强度合格！")
            break
        else:
            print("密码强度不合格！")
            try_time -= 1
        print()

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


if __name__ == '__main__':
    main()

• 读取保存的文件

判断密码强弱 4.0–增加功能：读取保存的密码

文件读操作

read():

readline(): 一行一行读（不缺点不知道多少行就没办法遍历完）

readlines(): 返回一个列表

想要读取则:

或者

输出结果为：

v_4.0代码如下：

"""
    作者：xpt
    功能：判断密码强弱
    版本：4.0
    日期：21/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
    3.0增加功能：保存设置的密码及其对应的强度到文件中
    4.0增加功能：读取保存的密码
"""


def main():
    """
    主函数
    """
    # 读取文件
    f = open('password.txt', 'r')

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

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

    # 3.readlines()
    for line in f:
        print('read:{}'.format(line))

    f.close()


if __name__ == '__main__':
    main()

• 这些方法都是与“密码操作”相关的，能否将这些方法封装成一个整体？

判断密码强弱 5.0–增加功能：将相关方法封装成一个整体：面向对象编程

面向过程vs面向对象

类的定义

一般大写来命名类，且不加下划线

password是需要传进来的参数

类的属性：

类的方法：

参数password_str，可以不要，因为password已经传进self.password了，直接换成self.password就可以了：

把处理字符串三个规则放进类中：

上图需要修改：

1、改成self.password

2、改成self.strength_level

3、函数现在已经在类里了，调用类里的函数需要加self.

4、不需要传password了，直接用self.password

修改之后如下：

综上，类的结构如下：

类的调用

其他：

类中定义方法时可以传入非初始属性的参数。

v_5.0代码如下：

"""
    作者：xpt
    功能：判断密码强弱
    版本：5.0
    日期：24/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
    3.0增加功能：保存设置的密码及其对应的强度到文件中
    4.0增加功能：读取保存的密码
    5.0增加功能：将相关方法封装成一个整体：面向对象编程
"""


class PasswordTool:
    """
     密码工具类
    """
    def __init__(self,password):
        # 类的属性
        self.password = password  # 类中的password,等于外面传进来的password
        self.strength_level = 0 # 密码强度

    # 类的方法（一般来说要加个self）
    def check_number_exist(self):
        """
        判断密码是否包含数字
        """
        has_number = False
        for x in self.password:
            if x.isnumeric():
                has_number = True
                break
        return has_number

    def check_alpha_exist(self):
        """
        判断密码是否包含数字
        """
        has_alpha = False
        for x in self.password:
            if x.isalpha():
                has_alpha = True
                break
        return has_alpha

    def process_password(self):
        # 规则1：密码长度大于8
        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_alpha_exist():
            self.strength_level += 1
        else:
            print('密码要求包含字母！')


def main():
    """
    主函数
    """
    try_time = 3  # 设置密码尝试次数
    while try_time > 0:
        password = input('请输入密码：')

        # 实例化密码工具对象
        password_tool = PasswordTool(password)
        password_tool.process_password()

        f = open('password.txt', 'a')
        f.write('密码：{}，强度:{}\n'.format(password, password_tool.strength_level))
        f.close()

        # 字符强度是否满足要求
        if password_tool.strength_level == 3:
            print("恭喜，密码强度合格！")
            break
        else:
            print("密码强度不合格！")
            try_time -= 1
        print()

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


if __name__ == '__main__':
    main()

单步调试debug

step into 跳进类中： （发现其跳到了类中初始化函数里了）

step over往下走：

step over再往下走：（发现跳出去了，PasswordTool初始化完成了）

step over继续往下：

step into跳进类里的方法：

然后一直往下就OK了，可以看到具体的一些过程。

• 将文件操作封装到一个类中

判断密码强弱 6.0–增加功能：将文件操作封装到一个类中

1、文件类初始化

需要传入的就是文件的路径

2、属性方法

3、实例化

v_6.0.1代码如下：
（文件读操作）

"""
    作者：xpt
    功能：判断密码强弱
    版本：6.0
    日期：26/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
    3.0增加功能：保存设置的密码及其对应的强度到文件中
    4.0增加功能：读取保存的密码
    5.0增加功能：将相关方法封装成一个整体：面向对象编程
    6.0增加功能：将文件操作封装到一个类中
"""


class PasswordTool:
    """
     密码工具类
    """
    def __init__(self,password):
        # 类的属性
        self.password = password  # 类中的password,等于外面传进来的password
        self.strength_level = 0 # 密码强度

    # 类的方法（一般来说要加个self）
    def check_number_exist(self):
        """
        判断密码是否包含数字
        """
        has_number = False
        for x in self.password:
            if x.isnumeric():
                has_number = True
                break
        return has_number

    def check_alpha_exist(self):
        """
        判断密码是否包含数字
        """
        has_alpha = False
        for x in self.password:
            if x.isalpha():
                has_alpha = True
                break
        return has_alpha

    def process_password(self):
        # 规则1：密码长度大于8
        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_alpha_exist():
            self.strength_level += 1
        else:
            print('密码要求包含字母！')

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 = 3  # 设置密码尝试次数
    filepath = 'password.txt'

    while try_time > 0:
        password = input('请输入密码：')

        # 实例化密码工具对象
        password_tool = PasswordTool(password)
        password_tool.process_password()

        # 实例化文件工具对象
        file_tool = FileTool(filepath)
        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()
        print('尝试次数过多，密码设置失败！')


if __name__ == '__main__':
    main()

v_6.0.2代码如下：
（文件读操作，在循环后面加上读操作，需要把实例化文件工具对象拿到循环外面去）

"""
    作者：xpt
    功能：判断密码强弱
    版本：6.0
    日期：26/11/2018
    2.0增加功能：限制密码设置次数；循环的终止
    3.0增加功能：保存设置的密码及其对应的强度到文件中
    4.0增加功能：读取保存的密码
    5.0增加功能：将相关方法封装成一个整体：面向对象编程
    6.0增加功能：将文件操作封装到一个类中
"""


class PasswordTool:
    """
     密码工具类
    """
    def __init__(self,password):
        # 类的属性
        self.password = password  # 类中的password,等于外面传进来的password
        self.strength_level = 0 # 密码强度

    # 类的方法（一般来说要加个self）
    def check_number_exist(self):
        """
        判断密码是否包含数字
        """
        has_number = False
        for x in self.password:
            if x.isnumeric():
                has_number = True
                break
        return has_number

    def check_alpha_exist(self):
        """
        判断密码是否包含数字
        """
        has_alpha = False
        for x in self.password:
            if x.isalpha():
                has_alpha = True
                break
        return has_alpha

    def process_password(self):
        # 规则1：密码长度大于8
        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_alpha_exist():
            self.strength_level += 1
        else:
            print('密码要求包含字母！')


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 = 3  # 设置密码尝试次数
    filepath = 'password.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()
        print('尝试次数过多，密码设置失败！')

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


if __name__ == '__main__':
    main()

面向对象的特点

• 封装
• 继承
• 多态

课后练习
• 加入更复杂的密码设置规则：

1. 同时包含大小写字母
2. 必须包含特殊符号，如：+, -, *, 等

Next?
• 随机数的生成
• 数据可视化
• 科学计算入门