Check if license plate number is formatted correctly

Question

I'm just learning Python and am looking for some feedback on some of the code exercises I've completed and do work. In particular, what would make them more Pythonic, or more closely align with standard practices or what-not.

Here is code I wrote for a loop exercise that works. It gets a license plate number from user, and checks that its formatted correctly. As I said, looking for feedback, but for right now, not looking to import anything, just better ways of writing what I've written. Btw, it's for, I suppose, a popular course, but it's already been turned in, so not trying to cheat, just learn, so any feedback will be appreciated. Thought maybe I should add details of what the code needed to check for to determine if plates were valid or not.

All vanity plates must start with at least two letters.

… vanity plates may contain a maximum of 6 characters (letters or numbers) and a minimum of 2 characters.

Numbers cannot be used in the middle of a plate; they must come at the end. For example, AAA222 would be an acceptable … vanity plate; AAA22A would not be acceptable. The first number used cannot be a ‘0’.

No periods, spaces, or punctuation marks are allowed.

def main():
    
    # Get user input
    plate = get_input()
    
    if is_valid(plate):
       print("Valid")
    else:
        print("Invalid")

def get_input():
    text = input("Enter plate text:")
    return text

def is_valid(s):
    #Check that plate is 2-6 character and starts with 2 letters.
    if len(s) >1 and len(s) <7 and s[0].isalpha() and s[1].isalpha():
        pass
    else:
        return False
        
#check that all text is alpha numeric
    for c in s:
        if c.isalnum() == True:
            continue
        else:
            return False
            
#Check that first number is not 0 and that there are no letters after a number

    i =0
    while i < len(s)-1:
        if s[i].isdigit() and s[i +1].isalpha() or s[i].isalpha() and s[i+1] == "0":
            return False
        i+=1
        
    return True
main()

Answer 1

Overview

The code layout is good, and you used meaningful names for some functions and variables.

Documentation

You should add documentation at the top of the code as a docstring to describe its purpose:

"""

Check if license plate number is formatted correctly.

The user enters a licenses plate string, and the code reports 
if it is valid or not.

"""

Indentation and spacing

There is some inconsistent indentation and spacing.

For example, the comments should be aligned with the code:

# check that all text is alpha numeric
for c in s:

The black program can be used to automatically indent and space things out for you.

Comments

Many of the comments in the code are good, but this one is not needed because you chose a meaningful name for the function:

# Get user input
plate = get_input()

You can delete that comment.

Naming

s is not a good name for a variable. Naming it text would be a little more meaningful.

Prompt

The input prompt message would be more helpful if it included details to guide the user on what constitutes a valid license plate. It would also be helpful to show examples of valid and invalid plates. For example:

def get_input():
    print("A valid license plate consists of:")
    print("  - 2 to 6 characters")
    text = input("Enter plate text:")

Invalid feedback

It would be extremely helpful to the user to see exactly why an entered plate is invalid. This would make the code longer and perhaps the valid check less efficient, but the user will be less frustrated trying to guess why it is invalid:

def is_valid(s):
    # Check that plate is 2-6 characters
    length = len(s)
    if length < 2 or length > 6:
        print(f"Must be 2-6 characters, not {length}")
        return False

    # starts with 2 letters.
    if not s[:2].isalpha():
        print("First 2 characters must be letters")
        return False

Answer 2

pass is very rarely needed in Python.

To take a pattern from the code here:

if condition:
    pass
else:
    return False

We can express that more clearly as

if not condition:
    return False

Similarly, a loop of the form

for:
    if condition:
        continue
    else:
        return False

can be

for:
    if not condition:
        return False

In concrete terms those would be

def is_valid(s):
    # Check that plate is 2-6 character and starts with 2 letters.
    if len(s) < 2 or len(s) > 6 or not s[0].isalpha() or not s[1].isalpha():
        return False

    # check that all subsequent text is alphanumeric
    for c in s[2:]:
        if not c.isalnum():
            return False

Actually, that loop might be better in functional style:

if not all(map(str.isalnum, s[2:])):
   return False

---

Note that hard-coding the rules for your region makes for code that's inflexible (e.g. it's not applicable where I live: your function would exclude many valid vehicle registration marks, but permit quite a few invalid ones too). It might be better to use a regular expression to test the validity, so that it's easier to use a different rule for each country.

Answer 3

Write unit tests. Currently your program is only interactive, but unattended tests will offer better confidence in your logic.

A regex is a pretty clear win here, and will simplify most of your logic, eliminating all of the loops and conditions that you wrote.

import re

LICENSE_PATTERN = re.compile(
r'''(?x)  # Verbose
    (?!   # Negative lookahead
        .{7,}  # Must be less than 7 characters
    )
    [A-Z]{2,}   # Start with letters; minimum of two
    (?:         # Non-capturing group, numbers (must come at the end)
        [1-9]   # First number cannot be '0'
        [0-9]*  # Any other numbers
    )?    # Numbers are optional
    $     # Anchor end
''')


def is_valid(s: str) -> bool:
    return LICENSE_PATTERN.match(s) is not None


def test() -> None:
    assert is_valid('AAA222')
    assert is_valid('XY')
    assert is_valid('ABCDEF')
    assert is_valid('AB1')
    assert is_valid('AB2000')

    assert not is_valid('AAA22A')   # letter at end
    assert not is_valid('AAAAA0')   # first number is 0
    assert not is_valid('ABCDEFG')  # too long
    assert not is_valid('123')      # no letters
    assert not is_valid('A1')       # not enough letters
    assert not is_valid('A')        # too short
    assert not is_valid('A98765')   # not enough letters


if __name__ == '__main__':
    test()

An alternative regex form that leverages the built-in digit class is

LICENSE_PATTERN = re.compile(
r'''(?x)  # Verbose
    (?=   # Positive lookahead
        [A-Z\d]{,6}  # Up to 6 numbers or letters
        $            # ...then the end
    )
    \D{2,}  # At least two non-digits
    (?!0)   # First digit cannot be '0'
    \d*     # Any digits
    $       # Anchor end
''')

The digit class is more inclusive than just the ASCII digits 0-9. Since the specification is ambiguous, this is fine in theory. In reality the specification would need to be more specific.

Answer 4

When possible and reasonable, make code that looks like the requirement

Given:
#Check that plate is 2-6 character and starts with 2 letters.

Instead of: if len(s) >1 and len(s) <7 and ...

Use: if len(s) >= 2 and len(s) <= 6 and ...

Answer 5

The whole while loop section at the bottom is unecessary (and a little clunky); you can check for both 'isalphanumeric' and letter following a number by iterating over the string just once by, for instance, keeping track of whether we've seen any numbers yet.

seen_digit = False
for character in s:
    
    if not character.isalnum():
        return False
    
    if seen_digit and character.isalpha():
        return False
    
    seen_digit = character.isdigit()
            
return True