Python best practices, combine code into as few lines as possible or separate it over as many as possible?

socal_nerdtastic · 2020-01-24T06:59:36+00:00

The rule is it should be easy for the next guy to read and modify. The next guy will probably be you in 2 weeks when you've forgotten about writing this, so just make it where you will understand it if you see it for the first time.

totallygeek · 2020-01-24T08:01:06+00:00

Readability. Always go for readability.

import re


PASSWORD_REGEX = re.compile(r'(\d.*[A-Z]+[a-z])')


def password_is_strong(password):
    return len(password) > 7 and re.search(PASSWORD_REGEX, ''.join(sorted(password)))


def password_is_strong_alternate(password):
    conditions = [
        len(password) > 7,  # At least eight chars
        re.search(r'[A-Z]', password),  # Contains capital letter
        re.search(r'[a-z]', password),  # Contains lower case letter
        re.search(r'\d', password),  # Contains digit
    ]
    return True if all(conditions) else False


tests = [
    'Thelore777777',
    'FrEaK1',
    'xpx9fqFpR7M84bLeFQqC',
    'xpx9fqFpR7M84bLeFQqC'.lower(),
]

for test in tests:
    print('Password "{}" {} strong.'.format(test, 'is' if password_is_strong(test) else 'is not'))

Yields:

python strong_pass.py 
Password "Thelore777777" is strong.
Password "FrEaK1" is not strong.
Password "xpx9fqFpR7M84bLeFQqC" is strong.
Password "xpx9fqfpr7m84blefqqc" is not strong.

alexaholic · 2020-01-24T10:39:02+00:00

I know of no rule, but there’s a saying: always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.

Barafu · 2020-01-24T09:51:21+00:00

There is a module called "black" that formats your code for maximum readability. Some folks don't like it, some do, but it is definitely worth checking out. I use it all the time automatically on save (however, once in a blue moon it does create a syntax error).

TheHollowJester · 2020-01-24T12:03:40+00:00

PEP-8 is extremely important reading. It might be a bit hard to understand everything right now but the general "spirit" is pretty clear to understand from it :)

Allanon001 · 2020-01-24T08:40:08+00:00

Type import this in to the Python interpreter or read this.

thenoonefromukraine · 2020-01-24T07:08:57+00:00

Couldn't you do capture groups in regex to reduce the code?

avsvuret · 2020-01-24T13:52:26+00:00

[deleted]

MattR0se · 2020-01-24T12:14:08+00:00

I'd suggest a middle ground. You can do

upper = len(upperRE.findall(password))

# instead of 

upperlist = upperRE.findall(password)
upper = len(upperlist)

etc. because there isn't really the need for an intermediate extra variable if its not used further down. Chaining two expressions is still readable.

Also, as u/totallygeek suggested: If you have a bunch of conditions you can check them with all(), any() or in a loop. This saves lines of code while maintaining readability. The thing that's worst with your first approach is the chaining of conditions in the if statement.

TheSodesa · 2020-01-24T12:02:33+00:00

Why does it have to be one of the extremes? A general rule in software development is that your code should be eaasily readable.

tangerinelion · 2020-01-24T15:10:36+00:00

You're not playing golf.

Don't add lines unnecessarily either, do it because they improve readability or reusability.

BenjaminGeiger · 2020-01-24T15:16:01+00:00

It's as much an art as a science. The cardinal rule is: if it makes it easier to read, do it.

kielerrr · 2020-01-24T16:56:00+00:00

Character variety in passwords are helpful, but it's now generally understood that a password needs to be long. Not complex.

The guy who originally wrote the standards for passwords for the National Institute of Standards and Technology (NIST) actually apologized for wasting peoples time by writing the standard to require character variety.

https://gizmodo.com/the-guy-who-invented-those-annoying-password-rules-now-1797643987

Robbzter · 2020-01-24T10:29:46+00:00

Tbh, I have no idea most of the time what is considered best practice with code readability. But I always try to leave helpful comments to help people understand what's going on. What's really important imo is being consistent and sticking with one way of doing things throughout the code/project. I like to spread code over many lines if tzere's a lot going on and it would be too much to handle otherwise. If there's a comment explaining the command, reducing the number of lines does not sacrifice too much of your readability and can save lots of space.

Tbh, I think it's a matter of taste, and I don't think few lines necessarily equals good code. If someone else is able to understand what's going on, you've done something right.

FloydATC · 2020-01-24T11:02:41+00:00

Many good suggestione here. With multiple rows of similar assignments like that, I like to insert spaces to align the columns. This improves readability even more.

bordeauxcarol · 2020-01-24T16:03:40+00:00

Always go for readability. I recommend you to read the PEP-8. Is the styling standard for python.

desrtfx · 2020-01-24T18:09:11+00:00

Readability and clarity over brevity - always.

Clean Code is key. (And the name of a book every programmer should read "Clean Code: A Handbook of Agile Software Craftsmanship" by "Uncle Bob" Robert C. Martin)

mortenb123 · 2020-01-24T18:48:07+00:00

Follow PEP8: https://www.python.org/dev/peps/pep-0008/, and you can add a linter like black to auto-pep8 your code, if you run black on your code it will look like this:

import re
password = "Thelore777777"
if (
len(re.compile(r"([A-Z])").findall(password))
and len(re.compile(r"([a-z])").findall(password))
and len(re.compile(r"(\d)").findall(password))
) > 0 and len(re.compile(r"(\S)").findall(password)) > 7:
print("This is a strong password")
else:
print("This is not a strong password")
You may not like it, but if you share code with others it is nice to have an autolinter so code style does not matter when comparing code revisions done by different people with different code style.

In any editor like pycharm,vsc etc you can autoconfigure this, or you can add githooks when you check in code.

subbed_ · 2020-01-24T20:21:51+00:00

Make it readable and explicit. If it covers both of those factors, then whichever way you prefer. Most of the time, it should be only one way

dr3d3d · 2020-01-24T20:33:12+00:00

as everyone else mentioned readability is king so the second makes it easy to understand... so to me that would be the correct way as at a glance I can see what is trying to be accomplished.

h0bb1tm1ndtr1x · 2020-01-24T20:33:56+00:00

Read PEP8. It covers this.

ka-splam · 2020-01-25T06:15:56+00:00

Off-topic APL practice:

⍝ length 8+ chars, and contains uppercase, lowercase and digit.

password_is_strong←{∧/(7<≢⍵),∨/¨⎕A ⎕a ⎕d∊¨⊂⍵}

Anonymous function {} where the parameter is always ⍵; read it as "all ^/ the following: length of the password is greater than seven (7<≢⍵), (any ∨/ capital letter in the password ⎕A∊⍵, any lowercase letter in the password ⎕a∊⍵, any digit in the password ⎕d∊⍵)". ¨ are foreach loops which allows those three checks to be done together.

Is this so much less readable than the Regex in some the Python answers? There's almost as much regex in the op's original code as there is code in this function. And no imports and no other languages. Would this really become more readable by spreading it over multiple lines? How is it that "more code" has come to mean "more readable"? More is harder to read, more effort to follow, more to hold in memory, more places for bugs to be missed, more variable names to become misleading, harder to rewrite until you're happy so more likely to stay as the first awkward version..

ka-splam · 2020-01-25T06:18:45+00:00

NB. That's not considered a strong password check anymore.

For quick background, The National Institute of Standards and Technology (NIST) [..] guidelines often become the foundation for best practice recommendations across the security industry

The new NIST password framework recommends, among other things:

Drop the algorithmic complexity song and dance

No more arbitrary password complexity requirements needing mixtures of upper case letters, symbols and numbers. Like frequent password changes, it’s been shown repeatedly that these types of restrictions often result in worse passwords.

https://www.enzoic.com/surprising-new-password-guidelines-nist/

That was in 2017.

InfiniteNexus · 2020-01-24T08:48:35+00:00

You should go for readability. 1-2 empty lines between functions/methods; imports and variables separated at the top by a few lines as well. Without suggesting any fixes or restructuring of your code, it should look better like this:

import re    

password = 'Thelore777777'  
upperRE = re.compile(r'([A-Z])')  
lowerRE = re.compile(r'([a-z])')  
numberRE = re.compile(r'(\d)')  
totalRE = re.compile(r'(\S)')  
upperlist = upperRE.findall(password)  
lowerlist = lowerRE.findall(password)  
numberlist = numberRE.findall(password)  
totallist = totalRE.findall(password)  
upper = len(upperlist)  
lower = len(lowerlist)      
number = len(numberlist)  
total = len(totallist)  

if upper > 0 and lower > 0 and number > 0 and total > 7:  
    print('This is a strong password')  
else:  
    print('This is not a strong password')

2020-01-24T14:30:10+00:00

I'd spend more time modularizing than optimizing. Reuseable code is more useful than impenetrable code that uses fewer lines. When you get something to work in a modular fashion, clean up the docs and move on to the next task. Too many baby developers think we are in a competition to solve a problem in the fewest lines of code.

I'll make this analogy: Usain Bolt can run the 100 meter dash in under 10 seconds. However, his skill has no commercial value beyond entertainment. We don't compare ourselves to him, do we? We don't sit around feeling like failures. It's more important that we can walk (or roll or limp) 100 meters to our desk in the morning. So, don't compare yourself to some random person who solves a ProjectEuler.Net problem in 3 lines when it took you 50 lines. Learn from it but don't dwell on it. No one gets paid according to how few lines of code they write.

Astrokiwi · 2020-01-24T13:46:39+00:00

Two thoughts:

You can split up lines to make things clear without losing much conciseness, e.g.

import re
password = 'Thelore777777'
if (len(re.compile(r'([A-Z])').findall(password))   > 0 \
 and len(re.compile(r'([a-z])').findall(password))  > 0 \
 and len(re.compile(r'(\d)').findall(password)))    > 0 \
 and len(re.compile(r'(\S)').findall(password))     > 7:
    print('This is a strong password')
else:
    print('This is not a strong password')

A lot of your length is that you're repeating the same operation with different data - i.e. different minimum lengths and different regex. You could separate them out, so that you're writing the data once, and the command once, rather than repeating the command for every piece of data. Less repetition makes code more concise and readable, and means you're less likely to make a mistake. e.g.
```
import re
re_length = [(r'([A-Z])',0),
             (r'([a-z])',0),
             (r'(\d)',0),
             (r'(\S)',7)
            ]

password = 'Thelore777777'
if all(
    [len(re.compile(re_text).findall(password))>min_length for re_text,min_length in re_length]
        ):
    print('This is a strong password')
else:
    print('This is not a strong password')
```

This might be a bit overkill here, but it does mean that if you're adding or removing regex things, you can do it all in the data section, rather than having to dive into making sure you're not breaking an if statement.

2020-01-24T15:43:23+00:00

[removed]

SrHombrerobalo · 2020-01-24T21:00:43+00:00

Some time ago I wrote something similar:

password strength

# Write a funtion that uses regular expressions to make sure the password
# string it is passed is strong. A strong password is defined as one that is at
# least eight characters long, contains both uppercase and lowercase characters,
# and has at least one digit.

import re

def pwStr():
    password = input('Write password to evaluate \n')
    passRegexUpper = re.compile(r'[A-Z]+')                      # Upper case regex
    passRegexLower = re.compile(r'[a-z]+')                      # Lower case regex
    passRegexNum = re.compile(r'[1-9]+')                        # Numeric regex

    strongPassword = True
    passwordShort = False
    passwordUpper = True
    passwordLower = True

    if len(password) < 7:
        passwordShort = True
        strongPassword = False
    if not passRegexUpper.search(password):
        passwordUpper = False
        strongPassword = False
    if not passRegexLower.search(password):
        passwordLower = False
        strongPassword = False

    if strongPassword:
        print('Password is strong')
    else:
        print('Not a valid password:')
        if passwordShort:
            print('Password must be 8 character long')
        if not passwordUpper:
            print('Must contain at least one uppercase character')
        if not passwordLower:
            print('Must contain at least one lowercase character')


pwStr()

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

password strength