Here's how I would get the longer string:

max(string_1, string_2, key=len) # Returns the longer string

The key keyword argument is a pattern you'll see frequently in python. It accepts a function as an argument (in our case len).

If you wanted to find the longest of multiple strings, you could do that too:

max('a', 'bc', 'def', 'ghi', 'jklm', key=len) # => 'jklm'

Warning:

This solution is not a great fit if you need to know when two strings are of equal length. If that's a requirement of yours, you'd be better off using a solution from one of the other answers.

I won't bother updating this approach to handle that requirement: that would feel like working against the language.

Limit execution to main module

It is customary for code that starts executing a series of commands to be surrounded in a special if-block:

if __name__ == '__main__':
 ...

This prevents the code from being executed when it is imported into another module.

It's probably a good idea to put most of your code into a method or two

Particularly once you've put your code inside a main block, the multiple levels of indentation can get a little messy quickly. It helps to put some of the code into a method and then call it, rather than just have it all in sequence:

def print_longer_string(s1, s2):
 ...

string1 = input("Enter first string: ")
string2 = input("Enter second string: ")
print_longer_string(string1, string2)

Use len

len is the standard mechanism for obtaining the length of a str, as well as any other sequence type.

Reduce repetition

You can reduce your if block to just two conditions by testing for equal lengths first and using a ternary:

if len(string1) == len(string2):
 print("Both strings are equal.")
else:
 print("Larger string is:")
 print(string1 if len(string1) > len(string2) else string2)

This allows you to avoid repeating the print("Larger string is:") line without having to move that message to a variable.

Use more descriptive messages

"Both strings are equal" doesn't really describe what the program is telling you. "Larger" can also have different meanings, as well. (It could refer to lexical sorting, for example.) "The strings have equal length" and "The longer string is:" would be more explicit and less likely to cause confusion. We could differentiate between character and byte length, if that won't be clear from context, but character length is the usual assumption and is what you get from Python 3 by default.

Formatting

Read PEP8 for Python's standards on the use of spaces around parentheses, indentation length, and blank lines. Your team might define their own standards, but PEP8 is the industry default.

Final code

Putting all these together, you will get something like

def print_longer_string(s1, s2):
 if len(s1) == len(s2):
 print("The strings have equal length")
 else:
 print("The longer string is:")
 print(s1 if len(s1) > len(s2) else s2)

if __name__ == '__main__':
 s1 = input("Enter the first string: ")
 s2 = input("Enter the second string: ")
 print_longer_string(s1, s2)

You'll note I also shortened the variables down to s1 and s2. string1 is actually fine as a variable name if you prefer; I just find s1 a bit quicker to read through. You usually want meaningful variable names, but there's no semantic meaning to these variables to capture in the name since it's just two arbitrary strings, so s1 doesn't really lose anything over string1.

I also want to note that I considered separating out the printing from actually picking which string to print. I decided not to separate them because the case of equal lengths was handled differently. This fact greatly reduced any benefit we would get from separating the determination from the actual IO call. Separating them would require either having a function that returns the full string to print (which has little value since the exact message is probably dependent on the IO mechanism anyway) or introducing an extra indicator in the return value to detect the equal length case (which is a level of complexity the program does not need yet under its current requirements).

Since Acccumulation's answer was considered too confusing, here's the same using a real Python ternary operator.

print('Equal' if len(s1) == len(s2) else 'Larger is ' + max(s1, s2, key=len))

I don't see the point in using .format for this kind of simple concatenation.

Building off of WeRelic and user201327 answers, if you really want to optimize for short code, you can do:

print(('Larger string is:'.format(max(string1,string2, key=len)),'Both strings are equal.')[len(string1)==len(string2)])

However, a more readable version would be

if len(string1)==len(string2):
 print('Both strings are equal.')
else:
 print('Larger string is:'.format(max(string1,string2, key=len))

Or, following JollyJoker's suggestion,

print( 'Both strings are equal.' if len(string1)==len(string2) 
 else 'Larger string is:'.format(max(string1,string2, key=len)))

Breaking down the short version:

max(string1,string2, key=len) returns the larger string, as measured by length

('Larger string is:'.format(max(string1,string2, key=len)) Takes the larger of the two strings, and inserts it into the string 'Larger string is:

('Larger string is:'.format(max(string1,string2, key=len)),'Both strings are equal.') creates tuple where the first value says what the larger string is, and the second element says they're equal

len(string1)==len(string2) returns a boolean based on whether the strings are equal length.

[len(string1)==len(string2)] takes one of the elements of the tuple, according to the value of len(string1)==len(string2). This coerces the boolean into an integer: False is considered to be 0 and retrieves the Larger string is: element. True is considered to be 1, and retrieves the 'Both strings are equal.' element.

Long live the Ternary:

def print_longer(s,s2):
 # return (s,s2)[len(s)<len(s2)] if you don't want to print within the function.
 print( ( s, s2 )[ len(s) < len(s2) ] )

Explanation:

if-else statements are clean, but they're verbose. A ternary operation would reduce this to a one-liner.

The format is as follows: (result_if_false,result_if_true)[comparison]

What is happening is that (s,s2) is creating a tuple of the two strings. len(s)<len(s2) then compares the two, and because they're within square brackets []; the boolean result is casted to an integer index.

Since you can only have a 0 or 1 result, this returns s if it is larger than s2, and vice-versa.

EDIT: This returns s if both strings are of equal lengths.

Here's how I would find the longest strings in a list of strings:

import itertools

def longest_string(strings):
 if not strings:
 return []

 strings_by_length = itertools.groupby(strings, len)
 maximum_length = max(strings_by_length.keys())
 return strings_by_length[maximum_length]

You can immediately assume that the first one is larger and then reassign it to the second one if that one is larger, like this:

larger = input("Enter first string: ")
string2 = input("Enter second string: ")
if (len(string2) > len(larger)):
 larger = string2
print(larger)