I want to know that 'password' is containd number using 'string.digits'
import string
def validate_password(password):
is_long = len(password)
if is_long < 8:
return False
includes_digit = password
for digit in string.digits:
if digit in includes_digit:
break
return False
for u in string.ascii_uppercase:
if u in includes_digit:
break
return False
for char in string.ascii_lowercase:
if char in password:
break
return False
return True
is_password_valid = validate_password("12345678ff")
print(is_password_valid)
I guess that is ok but didn't work
help me plz
In all of your validators, you don't return False because that return statement is underneath the if statement. You always break before reaching the return.
Put an else under your for loops like this. This part executes if the for loop finishes without encountering a break.
includes_digit = password
for digit in string.digits:
if digit in includes_digit:
break
else:
return False
You should use regex in this case.
import re
password = 'Azerty123'
contains_digit = bool(re.search('\d', password))
print(contains_digit) # True
Related
This is my code which and it asks a user to enter a password string and checks for any repeated elements.The thing is I didn't understand the code and why they set a unique_element to an empty string.And what does unique+=password[i] do,why is i in [] in this brackets?
def check_pass():
password= raw_input('Enter a password:')
unique_element = ''
for i in range (len(password)):
if len(unique_element) == 0:
unique_element += password [i]
else:
not_unique = True
for j in range (len(unique_element)):
if unique_element[j] == password[i]:
not_unique = False
if not_unique:
unique_element += password[i]
return unique_element == password
print check_pass()
Explaining the Code above may be a little tedious. Suffice it to say that if your intention is to check if a given String [password] contains any duplicate character, you might do that without the need for any loops - which (in this case) is likely unnecessary. Here's how:
def pass_has_unique_characters():
# CAPTURE THE ENTERED CHARACTERS
password = input('Enter a password:')
# SETS CANNOT HAVE DUPLICATES SO WE CAST THE STRING (password) TO A SET
st_password = set(password)
# NOW WE CHECK THE LENGTHS OF BOTH: password AND st_password
# IF BOTH HAVE THE SAME LENGTH, THEN THE PASS HAS UNIQUE CHARACTERS,
# RETURN [True] ... OTHERWISE RETURN [False]
return (True if len(st_password) == len(password) else False)
print(pass_has_unique_characters())
I have the following code to test a password for strength:
import string
def golf(password):
if len(password) >= 10:
if any(char.isdigit() for char in password):
if any(string.punctuation for char in password):
if any(char.isalpha() for char in password):
if any(char.isupper() for char in password):
if any(char.islower() for char in password):
return True
return False
I know it can be done better! It needs to test for the following ...
The password will be considered strong enough if it
has at least 10 characters
contains at least one digit
contains at least one uppercase letter
contains at least one lowercase letter. The password may only contain ASCII Latin letters or digits, but no punctuation symbols.
EDIT
OK for anyone else i got it down to the following with regex.
import re
def golf(password):
return re.match( r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.{10,30}).+$', password)
Apparently it can still be shorter...
Actually, you're quite close. Yes, you have a variety of conditions to check; the rules are that complication. Note that you don't have to check for alpha: the checks for islower and isupper cover that. You can make this just a little easier to handle by putting the rules into a single expression:
import string
def golf(password):
return \
len(password) >= 10 and \
any(char.isdigit() for char in password) and \
not any(string.punctuation for char in password) and \
any(char.isupper() for char in password) and \
any(char.islower() for char in password)
Note that you're evaluating a Boolean expression: just return that value. There's no need to say
if <expr>:
return True
else:
return False
You already have the value in hand; just return it.
That's one long string of if statements XD. You should just use some and statements.
if len(password) >= 10 and any(char.isdigit() for char in password)...:
return True
else:
return False
The else statement is not necessary, as you know, but it makes the code more readable.
The more optimal way would be to do your character checking all in one loop.
import string
def golf(password):
if len(password) < 10:
return False
saw_digit = saw_upper = saw_lower = False
no_punct = all_alnum = True
for char in password:
saw_digit = saw_digit or char.isdigit()
saw_upper = saw_upper or char.isupper()
saw_lower = saw_lower or char.islower()
no_punct = no_punct and (char not in string.punctuation)
all_alnum = all_alnum and char.isalnum()
values = [saw_digit, saw_lower, saw_upper, no_punct, all_alnum]
# print(values)
return all(values)
This question already has an answer here:
Variable checking, something not right
(1 answer)
Closed 6 years ago.
I have tried to make a 'password checker' program that checks if an entered variable contains specific characters. I will need it to check thee things: uppercase, lowercase and number.
There are 3 things that the program will hopefully output, and these are:
Weak, for passwords with only upper OR only lower OR only number
Medium, for passwords that have upper and lower, OR upper and number, OR lower and number
Strong, for passwords that contain upper, lower and number at the same time.
This is my code:
if EnteredPassword.isupper() or EnteredPassword.islower() or EnteredPassword.isdigit():
print ("Your password is weak")
elif EnteredPassword.isupper()and EnteredPassword.islower():
print ("Your password is medium")
elif EnteredPassword.isupper() and EnteredPassword.isdigit():
print ("Your password is medium")
elif EnteredPassword.islower() and EnteredPassword.isdigit():
print ("Your password is medium")
elif EnteredPassword.isupper() and EnteredPassword.islower() and EnteredPassword.isdigit():
print ("Your password is strong")
else:
print ("That password should not have been accepted")
quit()
However, when the program is run, and for example I have put in UPPERLOWER6 the program skips to the else statement. If I put something that just contains UPPER etc., that is the only one that works and comes up with your password is weak
If there is anything wrong with the code I cannot see, please point it out. I have been re-directed to other questions but they are too complicated for me and people would know I have copied is, which is not allowed.
Many thanks!
you should do something like this:
Password Tester in Python
the functions you are using test the whole string and to make what you want to do is not the right option.
Use regex. Its easier.
Your code isn't working the way you want it to because isupper, islower and isdigit all check all the values of the string you feed it. i.e. 'a'.islower() returns True, while 'aA'.is lower() returns False.
So,
if str.isupper() and str.islower():
#statement
is never executed because one of the conditions is always bound to be False.
Note: isupper and islower ignore any digits if any character is present in the string. i.e. 'a6'.islower() return True, while '6'.islower() and 'a6'.isdigit() return False.
isupper / islower is not working same as like isdigit.
upper and lower ignores any digits and whitespaces (eg "UPPER6 ".isupper() is True)
on the other way digit check if string contains only digits
Anyway 'UPPERLOWER6' matches first condition, so it shouldn't skip to else. You string probably contains something else.
You can still iterate over chars, eg:
flags = [False] * 3
for ch in EnteredPassword:
flags[0] = flags[0] or ch.islower()
flags[1] = flags[1] or ch.isupper()
flags[2] = flags[2] or ch.isdigit()
strength = sum(flags)
print("Your password is {}".format(
["not accepted", "weak", "medium", "strong"][strength])
)
You r doing it wrong way as you can use isupper or islower functions only on characters and not on whole string. I would do something like this:
def containsOnlyUpper(s):
for c in s:
if(not c.isupper()):
return False
return True
def containsOnlyLower(s):
for c in s:
if(not c.islower()):
return False
return True
def containsOnlyNumber(s):
for c in s:
if(not c.isdigit()):
return False
return True
def containsUpperAndLower(s):
hasUpper = False
hasLower = False
for c in s:
if (c.islower()):
hasLower = True
if (c.isupper()):
hasUpper = True
if(hasUpper and hasLower):
return True
else:
return False
def containsUpperAndNumber(s):
hasUpper = False
hasNumber = False
for c in s:
if (c.isupper()):
hasUpper = True
if (c.isdigit()):
hasNumber = True
if(hasUpper and hasNumber):
return True
else:
return False
def containsLowerAndNumber(s):
hasLower = False
hasNumber = False
for c in s:
if (c.islower()):
hasLower = True
if (c.isdigit()):
hasNumber = True
if(hasLower and hasNumber):
return True
else:
return False
def isWeakPassword(s):
if(containsOnlyUpper(s) or containsOnlyLower(s) or containsOnlyNumber(s)):
return True
return False
def isMediumPassword(s):
if(containsUpperAndLower(s) or containsUpperAndNumber(s) or containsLowerAndNumber(s)):
return True
return False
def isStrongPassword(s):
hasUpper = False
hasLower = False
hasNumber = False
for c in s:
if (c.isupper()):
hasUpper = True
if (c.islower()):
hasLower = True
if (c.isdigit()):
hasNumber = True
if (hasLower and hasUpper and hasNumber):
return True
else:
return False
password = "UPPERLOWER6"
if(isWeakPassword(password)):
print "weak"
elif(isMediumPassword(password)):
print "medium"
elif(isStrongPassword(password)):
print "strong"
else:
print "none"
I think you could set variables as flags, then check the letter and recording the number of occurrences in input one by one.
I need some help figuring out how to make a function that checks a string for a bunch of conditions.
Passwords must be at least 5 characters long
Passwords must contain at least one upper case letter
Passwords must contain at least two numbers
Passwords may not contain the characters "E" or "e"
Passwords must include at least one special symbol: !, #, #, $, %, ^, &
right now this is all that I have
def passwordChecker(password):
'''
'''
caps = sum(1 for c in password if c.isupper())
nums = sum(1 for c in password if c.isdigit())
symb = any(c in password for c in '!##$%^&')
note = any(c in password for c in 'Ee')
if len(password) <5:
return False
elif caps < 1:
return False
elif nums < 1:
return False
elif symb == False:
return False
else:
return True
Edit**
Just realized that I have to check also if there are commonly used passwords like 'password' or '111111' and I dont really know about how I would approach this.
Just an alternative using regular expressions:
import re
def passwordChecker(password):
return all(re.search(pattern, password) for pattern in
('.{5}', '[A-Z]', '\d.*\d', '^[^Ee]*$', '[!##$%^&]'))
Demo using five barely invalid and five barely valid tests (one invalid and one valid for each of the five rules):
for password in ('1A!', '12!34', 'A1bc!', 'A12E!', 'A12bc',
'1A!2.', 'A2!34', 'A12c!', 'A12b!', 'A12b#'):
print(passwordChecker(password))
Prints False for the first five and True for the last five.
you are just missing a branch
elif note:
return False
before the else:
This is a good time to talk about decorators! I love using decorators to validate data, probably too much. You could make validators for all that, and wrap it around your get_password method.
def v_length(password):
return len(password) >= 5
def v_upper(password):
return password.lower() != password
def v_2_nums(password):
return sum(c.isdigit() for c in password) >= 2
def v_no_e(password):
return "e" not in password.lower()
def v_specialchar(password):
any(s in password for s in "!##$%^&")
def validator(*tests):
def wrap(func):
def wrapped(*args, **kwargs):
result = func(*args, **kwargs)
if not all(test(result) for test in tests):
# fail the input somehow -- how??
return result
return wrapped
return wrap
#validator(v_length, v_upper, v_2_nums, v_no_e, v_specialchar)
def get_password():
pwd = input("Enter your password: ")
I like to wrap my validators in their own factories when I do this in real code, so that it's easier to change per application
def v_length(min_length):
def wrapped(password):
return len(password) >= min_length
return wrapped
#validator(v_length(8))
def get_weak_password():
input("Enter your wussy password: ")
#validator(v_length(64))
def get_strong_password():
input("Enter your Herculean password: ")
This second approach works well for checking for common passwords.
def v_common(common_pwd_set):
def wrapped(password):
return password not in common_pwd_set
return wrapped
COMMON_PASSWORDS = {"hunter2", "111111", "password"}
#validator(v_common(COMMON_PASSWORDS))
def get_password():
pwd = input("Use a tricksy one! ")
The following checks for each failure condition, with short-circuiting (it'll stop checking once it finds something). The "common" passwords aren't really common, but I wanted values that would pass the rest of the checks.
def passwordChecker(password):
'''
A password checker. Returns True if the password is acceptable; False otherwise.
'''
if (len(password) < 5 or
not any(c.isupper() for c in password) or
sum(c.isdigit() for c in password) < 2 or
'e' in password.lower() or
not (set(password) & set('!##$%^&')) or
password in {'Password12!', 'Passwd12!'}):
return False
return True
>>> passwordChecker('Password12!')
False
>>> passwordChecker('hi')
False
>>> passwordChecker('H12!')
False
>>> passwordChecker('Hi12!')
True
Yet another way to do this...
def passwordChecker(password):
return (len(password) > 4 and
len(filter(str.isupper, password)) > 0 and
len(filter(str.isdigit, password)) > 1 and
'e' not in password.lower() and
any(special in password for special in '!##$%^&') and
password not in ('password', '111111'))
I think the most interesting part of my solution is the use of filter; some people like it, others hate it. Anyway, all of the other solutions work just as well. Just thought I'd throw this one into the mix for completeness.
I'm trying to make a password with typical requirements like it has at least 1 uppercase/lowercase, etc. If the password is not valid according to the requirements, we have to display the errors in order for the user to try to get it correct again.
I started out with a while loop so that in the end the user will have an option to continue with another test or not. These are general steps I did.
At the end, if the user's text input is determined to not be valid, I have to display what his/her errors were. That's my main problem now. The code is better after a suggestion. Now I just have to display the errors somehow.
Here's how my code went
while True:
pw = input('Enter password to be tested if valid or not: ')
correct_length = False
uc_letter = False
lc_letter = False
digit = False
no_blanks = True
first_letter = False
if len(pw) >= 8:
correct_length = True
for ch in pw:
if ch.isupper():
uc_letter = True
if ch.islower():
lc_letter = True
if pw.isalnum():
digit = True
if pw[:1].isalpha():
first_letter = True
if not pw.find(' '):
no_blanks = True
if correct_length and uc_letter and lc_letter and digit and first_letter and no_blanks:
valid_pw = True
else:
valid_pw = False
#This is the part where I'm suppose to display the errors if the user gets it wrong.
#Initially, in the test for ch. above, I put in an else: with a print statement but because of the for- statement, it prints it out for every single character.
answer = input('Try another password input? y/n ')
if answer == 'y'
answer = True
else:
break
isdigit only returns True or False.
if ch.isdigit():
If you want to check if the first two characters are digits, do it outside the loop:
if pw[:2].isdigit():
digit = True
for ch in pw:
...
And to check if there are spaces in the string:
if not pw.find(' '):
no_blanks = True
Or if you want to escape all kinds of white spaces and blanks, including newline characters:
import string
...
if not any(c in string.whitespace for c in pw):
no_blanks = True
for ch in pw:
...
For the white space I would use (don't forget to import string):
import string
for ws in string.whitespace:
if ws in pw:
no_blanks = False
break
This checks for all kinds of white space, including for example Space and Tab
For the digits I would define dig_count = 0 before your for-loop.
Inside the for-loop:
if ch.isdigit():
dig_count += 1
After the for-loop:
if dig_count >= 2:
digit = True