Like this:

>>> mystr = "abcdefghijkl"
>>> mystr[-4:]
'ijkl'

This slices the string's last 4 characters. The -4 starts the range from the string's end. A modified expression with [:-4] removes the same 4 characters from the end of the string:

>>> mystr[:-4]
'abcdefgh'

For more information on slicing see this Stack Overflow answer.

You could do ed[-2:] but I noticed you have 1 to 2 digit numbers, there are many ways, one way is just to look for the number at last of the string using regex:

import re
pattern = re.compile('\d+$')
for i in range(0, len(links)):
    url = links[i]
    response = requests.get(url, cookies)
    soup = BeautifulSoup(response.content)
    pr = [f.text for f in soup.find_all(class_='lia-paging-full-wrapper lia-paging-pager lia-paging-full-left-position lia-discussion-page-message-pager lia-forum-topic-page-gte-5-pager lia-component-message-pager')]
    ed = [i.split('\n\n\n\n\n\nNext\n»\n\n\n\n', 1)[0] for i in pr]
    print(ed)
    if ed:
        page_count = pattern.findall(ed[0])
        print(page_count[0])
    else:
        print('ed is empty!')

OUTPUT:

23
ed is empty!
3
3
ed is empty!
ed is empty!
ed is empty!
ed is empty!
2
16
ed is empty!
ed is empty!
ed is empty!
2
ed is empty!

Sure you can do this using slicing.

p="\\.\E:"
result = p[-2:]  # Operates like: p[len(p) - 2 : len(p)]
# Where the colon (:) operator works as a delimiter that
# represent an "until" range. If the left hand starting
# value is missing it assumes a default 
# starting position of 0, if the right hand end position 
# value is missing it assumes the default to be the length 
# of the string operated upon. If a negative value is 
# passed to either the left or right hand value, it 
# assumes the length of the string - the value. 
print("result: " + result)
>> result: E:

Let's look at what happens above:

We slice the string p at position -2, this is because we want a generic approach that will always start stripping from the last two characters, this without knowing how many characters in length the string is.

If we knew it's always going to be a fix number of characters in length, say 4 characters then we could do:

result = p[2:]  # Every character from 2 and on wards
# Works like: p[2:len(p)] 

This would mean, result should contain every character that comes after index 2, this is because we do not specify a max value after the colon operator :, if we wanted to, for our previous example, we could do:

result = p[2:4]  # Every character from position 2 until 4

Thus, if one were to instead want the first two characters, one could do:

result = p[:2]  # Every character until position 2

Or:

result = p[0:2]  # Every character from 0 until 2

You might also want to check out: https://www.w3schools.com/python/gloss_python_string_slice.asp

cut by itself doesn't have the concept of "the last N characters" on a line. However if you combine this with the rev program you can reverse each line, select the first N characters, and then reverse the result to get things back to the original order.

 rev | cut -c 1-3 | rev