A particular data value does not yield the answer i was expecting

This is a program that is supposed to check following conditions for a number plates:

1. All vanity plates must start with at least two letters.
2. vanity plates may contain a maximum of 6 characters (letters or numbers) and a minimum of 2 characters.
3. 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’.
4. No periods, spaces, or punctuation marks are allowed.

Now, when I enter 'PK40' it yields 'invalid' but it is supposed to print 'valid' what am i doing wrong?

this is my code:

def main():
    plate = input("Plate: ")
    if is_valid(plate):
        print("Valid")
    else:
        print("Invalid")


def is_valid(s):
    check_length(s)
    if check_length(s):
        start_with_letters(s)
        if start_with_letters(s):
            zero_check(s)
            if zero_check(s):
                no_punctuation(s)
                if no_punctuation(s):
                    return True
                else:
                    return False
            else:
                return False
        else:
            return False
    else:
        return False


def check_length(str):
    if len(str)>= 2 and len(str)< 7:
        return True
    else:
        return False

def start_with_letters(str1):
    if str1[0:2].isalpha():
        return True
    else:
        return False

def zero_check(str2):
    index = 0
    while index < len(str2):         #inedx starts from 0 but len starts from 1, thus 'less than'
        if str2[index].isalpha() == False:    #AAA23A returns false at index = 3
            if str2[index] == "0":
                return False
            else:
                break          #because there is no 0 in the string
        index = index + 1

def no_punctuation(str3):
    i = 2
    punctuation = 0
    while i < len(str3) and punctuation == 0:
        char = str3[i]
        if char.isalpha() == False:          #if no alphabet is found, check for numbers
            if char.isdigit() == False:       #no digits
                punctuation += 1
        i =+ 1

    if punctuation == 0:
        return True
    else:
        return False

main()

1. the zero_check method does not return a truthy value in the success case. It has a default return of None which evaluates to False. You want:

def zero_check(str2):
    index = 0
    while index < len(str2):         #inedx starts from 0 but len starts from 1, thus 'less than'
        if str2[index].isalpha() == False:    #AAA23A returns false at index = 3
            if str2[index] == "0":
                return False
            else:
                break          #because there is no 0 in the string
        index = index + 1
    return True

2. no_punctuation calls i =+ 1 (i.e. i = +1 or i = 1) when it should be i += 1

def no_punctuation(str3):
    i = 2
    punctuation = 0
    while i < len(str3) and punctuation == 0:
        char = str3[i]
        if char.isalpha() == False:          #if no alphabet is found, check for numbers
            if char.isdigit() == False:       #no digits
                punctuation += 1
        i += 1

    if punctuation == 0:
        return True
    else:
        return False

Some improvements. isalpha and isdigit can be very misleading. For example:

>>> "⑴".isdigit()
True
>>> "à".isalpha()
True

Its better to be more granular in these cases. Using the range of ascii values would be safer:

def is_letter(c):
    return "A" <= c <= "Z"

def is_number(c):
    return "0" <= c <= "9"

Going further, I would break down each case you listed into their own method. You can also iterate through a string with the syntax for c in s: which will make this much cleaner. Your main is_valid method can simply combine the results of all calls together:

def main():
    plate = input("Plate: ")
    if is_valid(plate):
        print("Valid")
    else:
        print("Invalid")


def is_valid(s):
    return (
        correct_length(s)
        and two_letter_start(s)
        and no_letters_after_numbers(s)
        and all_letters_or_numbers(s)
    )


def correct_length(s):
    """
    Vanity plates may contain a maximum of 6 characters (letters or numbers) and a minimum of 2 characters.
    """
    return 2 <= len(s) <= 6


def two_letter_start(s):
    """
    All vanity plates must start with at least two letters.
    """
    return is_letter(s[0]) and is_letter(s[1])


def no_letters_after_numbers(s):
    """
    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’.
    """
    number_found = False
    for c in s:
        if not number_found:
            # The first number used cannot be a ‘0’.
            if c == "0":
                return False
            if is_number(c):
                number_found = True
        else:
            # Numbers cannot be used in the middle of a plate
            if is_letter(c):
                return False
    return True


def all_letters_or_numbers(s):
    """
    No periods, spaces, or punctuation marks are allowed.
    """
    for c in s:
        if not (is_letter(c) or is_number(c)):
            return False
    return True


def is_letter(c):
    return "A" <= c <= "Z"


def is_number(c):
    return "0" <= c <= "9"


if __name__ == "__main__":
    main()

Finally, using a regex, you can make this a one-liner:

import re


def main():
    plate = input("Plate: ")
    if is_valid(plate):
        print("Valid")
    else:
        print("Invalid")


def is_valid(s):
    return re.match(r"^(?=[A-Z0-9]{2,6}$)[A-Z]{2}[A-Z]*([1-9][0-9]*)?$", s)

Breakdown:

^                   Start of the string.
(?=                 Lookahead so we can assert an extra condition.
    [A-Z0-9]{2,6}   There will 2-6 letters or numbers.
    $               Then the string will end.
)
[A-Z]{2}            The first two characters are letters.
[A-Z]*              There can be more letters to follow.
(
  [1-9]             If there are numbers, they start with 1-9
  [0-9]*            Then we can have any amount of 0-9 digits
)?                  The digits are optional.
$                   Then the string ends.