This requires Biopython. Save it as extractEnds.py and chmod +x extractEnds.py to make it executable and then just run it

#!/usr/bin/python

import sys
from sys import argv
from Bio import SeqIO

if (len(sys.argv) < 2):
    print("Usage: extractEnds.py file.fna")
    sys.exit()
else:
    FNAME = argv[1]
    IFILE = open(FNAME, "rU")

for record in SeqIO.parse(IFILE, "fasta"):
    print(">%s\n%s" % (record.description, record.seq[-1000:]))

IFILE.close()

I'm quite a Python noob so if there's a way to make this better or there are mistakes, please let me know..

linearize and use a second awk to extract the last 100 characters.

awk '/^>/ {printf("%s%s\t",(N>0?"\n":""),$0);N++;next;} {printf("%s",$0);} END {printf("\n");}'  input.fasta |\
awk -F '\t' '{x=100;L=length($2);printf("%s\n%s\n",$1,(L<=x?$2:substr($2,1+L-x,x)));}'

sed would work here, and you should learn about regular expressions (or regexs). If you aren't familiar with them. sed is a tool to edit files generally based on a pattern matching syntax, and regular expression are how those patterns are described. This might be a good start to learn regexs: https://regexone.com/ They'll likely become a very useful tool as you get more into bioinformatics.

The solution is to tell sed to "modify any line that doesn't start with a >, and any other line should be truncated to keep only the last 1000 characters. Since you know this is a FASTA file, you can assume than any line that starts with > should be left untouched. Then, your regex needs to do the truncation.

Here's an example to illustrate: I created a dummy file with two lines (one header row, and one row with 999 As and 1001 Bs), so the expected output is ABBBB...(such that there's 999 B's.) The sed command is:

$ sed 's|^[^>].*\(.\{1000\}\)|\1|g' file.txt
>fasta_header
ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

This may be really hard to understand and parse out on the first go and naturally regexes are not intuitive at first, you really just have to learn the commands and syntax. Don't get discouraged if you don't understand it all, just keep in mind that it's something that's possible to do with tools like sed and regexes.

Detail about the command, if you're interested: Sed will evaluate the expression line by line in the text file. The syntax for a replacement is `sed 's|pattern|replacement|g'. There's other types of sed command too.

The regex, |^[^>].*\(.\{1000\}\)|\1| means matchin from the begining of the file (^) any character that isn't > (that's [^>], it means "not >" essentially.), for an unlimited amount of characters (.*) up until any other character times 1000, .*\(.\{1000\}\). Because you used .*, sed will use greedy matching and go all the way until the end of the string, leaving you the last 1000 characters.

The \ here aren't actually part of the regex and are just there so sed doesn't interpret the ( ) { } as part of the expression, but rather as a regular expression group ( ) and a repeat character {NUMBER}. Really it should be (.{1000}) which means a group of any 1000 characters.

The group ( ) is a special regular expression construct that let's you re-use part's you've matched of your regex. Since it's the first (and only) group in the expression, the second part of the sed command (\1) means replace whatever the regular expression matched (if there's a match, so not applicable to headers) to whatever is inside the group (which should be the last 1000 characters).