Python - How to Concatenate Strings in a Successive Way?

If your fields are E1 through E7 and each has a get method this should give you the total length of them:

fields = [E1, E2, E3, E4, E5, E6, E7]
total_length = sum(len(str(f.get())) for f in fields)

If you just want the values collected, this suffices:

fields = [E1, E2, E3, E4, E5, E6, E7]
values = [f.get() for f in fields]

i'll try answer the second part of the question since @g.d.d.c already has a very good answer to the first part.

To avoid code repeat you should look at common sections among your existing code.

if string_length == 22*S.get():
    ...
else:
    warning()

appears in all three cases. Therefore you can extract it to be:

if string_length != 22*S.get():
    warning()
else:     
    if S.get() == 1:
        ...
    elif S.get() == 2:
        ...
    elif S.get() == 3:
        ...
    do_something()

if you foresee to support more cases, you can expand with a function map

functions = {1 : one,
                2 : two,
                3 : three
}

def one():
    m = partL + str(E1.get()) + partR

def two():
    m = partL + str(E1.get()) + partM + str(E2.get()) + partR

def three():
    m = partL + str(E1.get()) + partM + str(E2.get()) + partM + str(E3.get())

and you call with:

functions[S.get()]()

The if string_length == 22*S.get() check happens regardless of the value of S.get(), and if it fails, you always raise a warning. To simplify your code and reduce code duplication, you can move that check outside of the logic that switches based on the value of S.get():

if string_length != 22*S.get():
    warning()
else:
    if S.get() == 1:
        ...
    elif S.get() == 2:
        ...
    ...

If you make a list of fields instead of using 7 numbered variables, it's easy to use slicing and indexing to select the fields you want in a scalable way without needing separate clauses for every number. Also, the join method of strings allows you to join together a number of strings with a delimiter you specify:

if string_length != 22*S.get():
    warning()
else:
    middle = partM.join(str(field.get()) for field in fields[:S.get()])
    m = partL + middle + partR
    do_something()

Let's break down partM.join(str(field.get()) for field in fields[:S.get()]):

fields should be the list of fields you made instead of using 7 variables.

fields[:S.get()] is slicing notation. It makes a list of the first S.get() elements of fields. (If fields doesn't have enough elements, the slice returns a copy of the whole list.)

str(field.get()) for field in fields[:S.get()] is a generator expression. It creates an iterator that loops over fields[:S.get()] and calls the get() method of every field in the list. This results in an iterator over the strings from the first S.get() fields. (Generator expressions must always appear in parentheses. If a generator expression is the only argument to a function, the function call parentheses fill this role. Otherwise, you must stick parentheses around it.)

partM.join(str(field.get()) for field in fields[:S.get()]) takes all the strings from that iterator and sticks them together, separated by partM between each pair of strings.

Well a way to join strings in to use the .join(insert something here) method. This is basically the string equivalent of the function .append(Insert something here).