2022年 11月 13日

判断密码强度(Python)

用户设置密码后,判断密码强度是否合格,判断规则:1.密码长度不小于8;2.密码中必须包含字母;3.密码中必须包含数字。

1.0:isnumeric()函数可以判断字符串中是否只含有数字,若字符串中只含数字,返回True;isalpha()函数可以判断字符串字符串中是否只含有字母,若字符串中只包含字母,返回True。初始化密码强度strength_level为0,每满足一个判断规则就加1。判断密码强度时,只要含有字母(不是只含有字母)即可,因此对输入的密码字符串进行遍历,遇到字母后停止遍历,如果密码中含有字母,strength_level+1。对数字的判断同样处理。当密码强度为3时,给用户提示:密码强度合格,否则说明不合格原因。

  1. """
  2. 判断密码强度
  3. 1.0:密码长度大于8
  4. 包含数字
  5. 包含字母
  6. """
  7. def check_number_exit(password):
  8. """
  9. 判断是否含有数字
  10. """
  11. for x in password:
  12. if x.isnumeric():
  13. return True
  14. return False
  15. def check_letter_exit(password):
  16. """
  17. 判断是否含有字母
  18. """
  19. for x in password:
  20. if x.isalpha():
  21. return True
  22. return False
  23. def main():
  24. """
  25. 主函数
  26. """
  27. password_str = input("请输入密码:")
  28. strength_level = 0
  29. #规则1:密码长度大于8
  30. if len(password_str) >= 8:
  31. strength_level += 1
  32. else:
  33. print("抱歉!密码长度应不小于8位!")
  34. #规则2:包含数字
  35. if check_number_exit(password_str):
  36. strength_level +=1
  37. else:
  38. print("抱歉!密码中应包含数字!")
  39. #规则3:包含数字
  40. if check_letter_exit(password_str):
  41. strength_level +=1
  42. else:
  43. print("抱歉!密码中应包含字母!")
  44. if strength_level ==3:
  45. print("您的密码强度合格!")
  46. else:
  47. print("您设置的密码强度不合格!")
  48. if __name__=="__main__":
  49. main()

2.0:主要是终止循环(break)的用法。对判断是否含有字母和数字的函数进行了优化,同时改进主函数,使用户可以多次设置密码。设置输入密码次数 times=5,用户输入密码不合格时,提醒用户重新输入,同时times-1,若用户输入的密码合格,则直接跳出循环。当用户输入5 次后密码仍然不合格时,提醒用户输入次数过多。

  1. """
  2. 判断密码强度
  3. 2.0: 终止循环,限定输入密码的次数
  4. """
  5. def check_number_exit(password):
  6. """
  7. 判断是否含有数字
  8. """
  9. number = False
  10. for x in password:
  11. if x.isnumeric():
  12. number = True
  13. break
  14. return number
  15. def check_letter_exit(password):
  16. """
  17. 判断是否含有字母
  18. """
  19. letter = False
  20. for x in password:
  21. if x.isalpha():
  22. letter = True
  23. break
  24. return letter
  25. def main():
  26. """
  27. 主函数
  28. """
  29. times = 5
  30. while(times >0 ):
  31. password_str = input("请输入密码:")
  32. strength_level = 0
  33. #规则1:密码长度大于8
  34. if len(password_str) >= 8:
  35. strength_level += 1
  36. else:
  37. print("抱歉!密码长度应不小于8位!")
  38. #规则2:包含数字
  39. if check_number_exit(password_str):
  40. strength_level +=1
  41. else:
  42. print("抱歉!密码中应包含数字!")
  43. #规则3:包含数字
  44. if check_letter_exit(password_str):
  45. strength_level +=1
  46. else:
  47. print("抱歉!密码中应包含字母!")
  48. if strength_level ==3:
  49. print("您的密码强度合格!")
  50. break
  51. else:
  52. print("您设置的密码强度不合格!")
  53. times -= 1
  54. print()
  55. if times == 0:
  56. print("您输入密码次数超过已5次,暂不可用!")
  57. if __name__=="__main__":
  58. main()

3.0:将设置的密码及对应的强度以及强度级别保存到文件中。定义密码强度级别,1:弱;2:中;2:强。文件的操作:f = open(),括号中输入文件路径以及打开方式(r:只读,文件不存在时报错;w:只写,文件不存在时自动新建文件;r+:可读可写;a:可以持续性输入,保留原来的输入结果)。f.write()写入内容。f.close()关闭文件。文件打开要在判断密码强度是否合格之前,否则只能保存合格的密码。

  1. """
  2. 判断密码强度
  3. 3.0:将设置的密码以及对应的强度保存到文件中
  4. """
  5. def check_number_exit(password):
  6. """
  7. 判断是否含有数字
  8. """
  9. number = False
  10. for x in password:
  11. if x.isnumeric():
  12. number = True
  13. break
  14. return number
  15. def check_letter_exit(password):
  16. """
  17. 判断是否含有字母
  18. """
  19. letter = False
  20. for x in password:
  21. if x.isalpha():
  22. letter = True
  23. break
  24. return letter
  25. def main():
  26. times = 5
  27. while(times >0 ):
  28. password_str = input("请输入密码:")
  29. strength_level = 0
  30. #规则1:密码长度大于8
  31. if len(password_str) >= 8:
  32. strength_level += 1
  33. else:
  34. print("抱歉!密码长度应不小于8位!")
  35. #规则2:包含数字
  36. if check_number_exit(password_str):
  37. strength_level +=1
  38. else:
  39. print("抱歉!密码中应包含数字!")
  40. #规则3:包含数字
  41. if check_letter_exit(password_str):
  42. strength_level +=1
  43. else:
  44. print("抱歉!密码中应包含字母!")
  45. if strength_level == 1:
  46. level = "弱"
  47. elif strength_level == 2:
  48. level = "中"
  49. else:
  50. level = "强"
  51. f = open("password.3.0.txt","a")
  52. f.write("密码:{}\t强度:{}\t级别:{}\n".format(password_str,strength_level,level))
  53. f.close()
  54. if strength_level ==3:
  55. print("您的密码强度合格!")
  56. break
  57. else:
  58. print("您设置的密码强度不合格!")
  59. times -= 1
  60. print()
  61. if times == 0:
  62. print("您输入密码次数超过已5次,暂不可用!")
  63. if __name__=="__main__":
  64. main()

4.0:读取文件中的密码(只截取读取文件的代码)。以只读的方式打开文件,g.read():读取所有的文件信息,返回一个包含所有文件信息的字符串;g.readline()返回值为文件下一行内容的字符串;g.readlines():返回值为整个文件内容的列表,每项是以换行为结尾的一行字符串。关于文件信息的遍历有两种方式:(1)for line in g (2)for line in g.readlines()

  1. g = open("password.3.0.txt", "r")
  2. #read = g.read()
  3. #print(read)
  4. #line = g.readline()
  5. #print(line)
  6. #lines = g.readlines()
  7. #print(lines)
  8. #for line in g:
  9. # print(line)
  10. for line in g.readlines():
  11. print(line)

5.0:面向对象,定义一个密码工具类,首先定义密码属性,然后写入判断是否含有字母和数字的函数,最后写入计算密码强度的函数。

  1. """
  2. 判断密码强度
  3. 5.0:面向对象,定义一个密码工具类
  4. """
  5. class PasswordTool:
  6. #自身属性
  7. def __init__(self,password):
  8. self.password = password
  9. self.strength_level = 0
  10. self.level = ""
  11. def check_number_exit(self):
  12. number = False
  13. for x in self.password:
  14. if x.isnumeric():
  15. number = True
  16. break
  17. return number
  18. def check_letter_exit(self):
  19. letter = False
  20. for x in self.password:
  21. if x.isalpha():
  22. letter = True
  23. break
  24. return letter
  25. def password_tool(self):
  26. if len(self.password) >= 8:
  27. self.strength_level += 1
  28. else:
  29. print("抱歉!密码长度应不小于8位!")
  30. if self.check_number_exit():
  31. self.strength_level += 1
  32. else:
  33. print("抱歉!密码中应包含数字!")
  34. if self.check_letter_exit():
  35. self.strength_level += 1
  36. else:
  37. print("抱歉!密码中应包含字母!")
  38. if self.strength_level == 1:
  39. self.level = "弱"
  40. elif self.strength_level == 2:
  41. self.level = "中"
  42. else:
  43. self.level = "强"
  44. def main():
  45. times = 5
  46. while(times >0 ):
  47. password_str = input("请输入密码:")
  48. example = PasswordTool(password_str)
  49. example.password_tool()
  50. f = open("password.5.0.txt","a")
  51. f.write("密码:{}\t强度:{}\t级别:{}\n".format(example.password,example.strength_level,example.level))
  52. f.close()
  53. if example.strength_level ==3:
  54. print("您的密码强度合格!")
  55. break
  56. else:
  57. print("您设置的密码强度不合格!")
  58. times -= 1
  59. print()
  60. if times == 0:
  61. print("您输入密码次数超过已5次,暂不可用!")
  62. if __name__=="__main__":
  63. main()

6.0:定义一个文件操作类。将关于文件读写操作的函数写入类中。

  1. """
  2. 判断密码强度
  3. 6.0:面向对象,定义一个文件操作类
  4. """
  5. class Filetool:
  6. def __init__(self,filepath):
  7. self.filepath = filepath
  8. def read_from_file(self):
  9. f = open(self.filepath,"r")
  10. lines = f.readlines()
  11. f.close()
  12. return lines
  13. def write_to_file(self,line):
  14. f = open(self.filepath,"a")
  15. f.write(line)
  16. f.close()
  17. class PasswordTool:
  18. #自身属性
  19. def __init__(self,password):
  20. self.password = password
  21. self.strength_level = 0
  22. self.level = ""
  23. def check_number_exit(self):
  24. number = False
  25. for x in self.password:
  26. if x.isnumeric():
  27. number = True
  28. break
  29. return number
  30. def check_letter_exit(self):
  31. letter = False
  32. for x in self.password:
  33. if x.isalpha():
  34. letter = True
  35. break
  36. return letter
  37. def password_tool(self):
  38. if len(self.password) >= 8:
  39. self.strength_level += 1
  40. else:
  41. print("抱歉!密码长度应不小于8位!")
  42. if self.check_number_exit():
  43. self.strength_level += 1
  44. else:
  45. print("抱歉!密码中应包含数字!")
  46. if self.check_letter_exit():
  47. self.strength_level += 1
  48. else:
  49. print("抱歉!密码中应包含字母!")
  50. if self.strength_level == 1:
  51. self.level = "弱"
  52. elif self.strength_level == 2:
  53. self.level = "中"
  54. else:
  55. self.level = "强"
  56. def main():
  57. times = 5
  58. path = "pwd_level6.0.txt"
  59. f = Filetool(path)
  60. while(times >0 ):
  61. password_str = input("请输入密码:")
  62. example = PasswordTool(password_str)
  63. example.password_tool()
  64. line = "密码:{}\t强度:{}\t级别:{}\n".format(example.password,example.strength_level,example.level)
  65. f.write_to_file(line)
  66. if example.strength_level ==3:
  67. print("您的密码强度合格!")
  68. break
  69. else:
  70. print("您设置的密码强度不合格!")
  71. times -= 1
  72. print()
  73. if times == 0:
  74. print("您输入密码次数超过已5次,暂不可用!")
  75. word = f.read_from_file()
  76. print(word)
  77. if __name__=="__main__":
  78. main()